Add Pydantic AI shared engine definition and smoke test

.github/aw/engines.json

@@ -27,6 +27,10 @@
     {
       "id": "opencode",
       "import": "github/gh-aw/.github/workflows/shared/opencode.md"
+    },
+    {
+      "id": "pydantic-ai",
+      "import": "github/gh-aw/.github/workflows/shared/pydantic.md"
     }
   ]
 }

.github/workflows/shared/pydantic.md

@@ -0,0 +1,140 @@
+---
+runtimes:
+  uv:
+    version: latest
+pre-agent-steps:
+  - name: Predownload Pydantic AI CLI
+    run: uv run pai --version
+engine:
+  id: pydantic-ai
+  version: "0.1.0"
+  display-name: Pydantic AI
+  description: Pydantic AI headless coding agent CLI with MCP support
+  experimental: true
+  mcp: true
+  provider:
+    name: github
+  behaviors:
+    secret-strategy: universal-llm-consumer
+    manifest:
+      files:
+        - AGENTS.md
+      path-prefixes:
+        - .pydantic-ai/
+    network:
+      defaults:
+        - host.docker.internal
+        - github.com
+        - raw.githubusercontent.com
+        - api.github.com
+        - objects.githubusercontent.com
+      provider-domains:
+        copilot: api.githubcopilot.com
+        anthropic: api.anthropic.com
+        openai: api.openai.com
+    execution:
+      command-name: uv
+      args:
+        - run
+        - pai
+        - run
+      step-name: Execute Pydantic AI CLI
+      model-env-var: PAI_MODEL
+      mcp-config-env-var: GH_AW_MCP_CONFIG
+      write-timestamp: true
+      provider-env-mode: universal-llm-consumer
+    log-parser: |
+      function parseLog(logContent) {
+        const lines = logContent.split("\n");
+        const logEntries = [];
+        const mcpFailures = [];
+        let maxTurnsHit = false;
+        const AWF_INFRA_RE = /^\[(INFO|WARN|SUCCESS|ERROR|entrypoint|health-check)\]|^ (?:Container|Network|Volume) |^Process exiting with code:/;
+        let inputTokens = 0;
+        let outputTokens = 0;
+        let toolCallIndex = 0;
+        let turnCount = 0;
+        let pendingText = [];
+
+        function flushText() {
+          if (pendingText.length === 0) return;
+          const text = pendingText.join("\n").trim();
+          if (text) {
+            logEntries.push({ type: "assistant", message: { content: [{ type: "text", text }] } });
+            turnCount++;
+          }
+          pendingText = [];
+        }
+
+        logEntries.push({ type: "system", subtype: "init", model: null, session_id: null });
+
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          if (AWF_INFRA_RE.test(line)) continue;
+          if (/max.?turns|maximum.*turns.*reached|turn limit/i.test(line)) maxTurnsHit = true;
+          if (/MCP server .* failed|MCP.*connection.*error|Failed to connect to MCP/i.test(line)) {
+            const serverMatch = line.match(/MCP server ['"]?([^\s'"]+)['"]?/i);
+            mcpFailures.push(serverMatch ? serverMatch[1] : line.trim());
+          }
+
+          let parsed = null;
+          try {
+            if (line.trim().startsWith("{")) parsed = JSON.parse(line.trim());
+          } catch (e) { /* not JSON */ }
+
+          if (parsed) {
+            if (parsed.input_tokens) inputTokens += parsed.input_tokens;
+            if (parsed.output_tokens) outputTokens += parsed.output_tokens;
+            const entryType = parsed.type != null ? String(parsed.type) : "log";
+            const msg = parsed.msg || parsed.message || parsed.content || "";
+
+            if (/tool[._]call|tool[._]use/i.test(entryType)) {
+              flushText();
+              const toolId = `pai_tool_${toolCallIndex++}`;
+              const toolName = parsed.tool || parsed.name || entryType;
+              logEntries.push({ type: "assistant", message: { content: [{ type: "tool_use", id: toolId, name: toolName, input: {} }] } });
+              logEntries.push({ type: "user", message: { content: [{ type: "tool_result", tool_use_id: toolId, content: msg }] } });
+            } else if (msg) {
+              pendingText.push(msg);
+            }
+          } else {
+            pendingText.push(line.trim());
+          }
+        }
+        flushText();
+
+        const usage = {};
+        if (inputTokens) usage.input_tokens = inputTokens;
+        if (outputTokens) usage.output_tokens = outputTokens;
+        logEntries.push({ type: "result", num_turns: turnCount, usage });
+        const parts = [`**Turns:** ${turnCount}`, `**Tool calls:** ${toolCallIndex}`];
+        if (inputTokens || outputTokens) parts.push(`**Tokens:** ${((inputTokens ?? 0) + (outputTokens ?? 0)).toLocaleString()}`);
+        if (mcpFailures.length) parts.push(`**MCP failures:** ${mcpFailures.length}`);
+        if (maxTurnsHit) parts.push("**Max turns reached**");
+        return { markdown: parts.join(" · "), logEntries, mcpFailures, maxTurnsHit };
+      }
+---
+
+<!--
+# Pydantic AI
+
+Shared engine definition for [Pydantic AI](https://ai.pydantic.dev), the
+headless AI coding agent. Import this file and set `engine: id: pydantic-ai`
+to use it:
+
+```yaml
+engine:
+  id: pydantic-ai
+model: copilot/claude-sonnet-4-5
+imports:
+  - shared/pydantic.md
+```
+
+`model` must use `provider/model` format. Supported providers are `copilot`,
+`anthropic`, and `openai`. Requests are routed through the AWF proxy.
+
+The engine reads MCP server configuration from `GH_AW_MCP_CONFIG`, so
+safe outputs flow through the standard `safeoutputs` server automatically.
+
+Pydantic AI is preinstalled in the runtime image.
+-->