@h-rig/provider-plugin 0.0.6-alpha.156

package/README.md

@@ -0,0 +1 @@
+# @h-rig/provider-plugin

package/dist/src/claude-stream-records.d.ts

@@ -0,0 +1,24 @@
+import type { EngineRunLog } from "@rig/contracts";
+type ClaudeStreamStatus = EngineRunLog["status"];
+export type PendingClaudeToolUse = {
+    id: string;
+    name: string | null;
+    input: unknown;
+    timestamp: string;
+    record: Record<string, unknown>;
+};
+type BuildClaudeLogsFromRecordInput = {
+    runId: string;
+    record: Record<string, unknown>;
+    createdAtFallback: string;
+    status: ClaudeStreamStatus;
+    pendingToolUses: Map<string, PendingClaudeToolUse>;
+    includeMessageLogs?: boolean;
+};
+export declare function buildClaudeLogsFromRecord(input: BuildClaudeLogsFromRecordInput): EngineRunLog[];
+export declare function flushPendingClaudeToolUseLogs(input: {
+    runId: string;
+    status: ClaudeStreamStatus;
+    pendingToolUses: Map<string, PendingClaudeToolUse>;
+}): EngineRunLog[];
+export {};

package/dist/src/claude-stream-records.js

@@ -0,0 +1,158 @@
+// @bun
+// packages/provider-plugin/src/claude-stream-records.ts
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function normalizeString(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function normalizeIsoTimestamp(value) {
+  const normalized = normalizeString(value);
+  if (!normalized) {
+    return null;
+  }
+  const timestamp = Date.parse(normalized);
+  return Number.isNaN(timestamp) ? null : new Date(timestamp).toISOString();
+}
+function buildClaudeLogsFromRecord(input) {
+  const logs = [];
+  const entryType = normalizeString(input.record.type);
+  const createdAt = normalizeIsoTimestamp(input.record.timestamp) ?? input.createdAtFallback;
+  if (entryType === "summary") {
+    return logs;
+  }
+  if (entryType === "system" || entryType === "result") {
+    logs.push({
+      id: normalizeString(input.record.uuid) ?? `${input.runId}-claude-${Date.now()}`,
+      runId: input.runId,
+      title: entryType === "result" ? "Agent result" : "Agent session initialized",
+      detail: JSON.stringify(input.record),
+      tone: entryType === "result" && input.record.is_error === true ? "error" : "info",
+      status: input.status,
+      payload: input.record,
+      createdAt
+    });
+    return logs;
+  }
+  const message = asRecord(input.record.message);
+  if (!message) {
+    return logs;
+  }
+  const role = normalizeString(message.role) ?? entryType ?? "assistant";
+  const content = Array.isArray(message.content) ? message.content : [];
+  for (const item of content) {
+    const contentRecord = asRecord(item);
+    if (!contentRecord) {
+      continue;
+    }
+    const contentType = normalizeString(contentRecord.type);
+    if (contentType === "tool_use") {
+      const toolUseId = normalizeString(contentRecord.id) ?? normalizeString(contentRecord.tool_use_id);
+      if (!toolUseId) {
+        continue;
+      }
+      input.pendingToolUses.set(toolUseId, {
+        id: toolUseId,
+        name: normalizeString(contentRecord.name) ?? normalizeString(contentRecord.tool_name),
+        input: contentRecord.input ?? contentRecord.tool_input ?? {},
+        timestamp: createdAt,
+        record: contentRecord
+      });
+      continue;
+    }
+    if (contentType === "tool_result") {
+      const toolUseId = normalizeString(contentRecord.tool_use_id);
+      const pending = toolUseId ? input.pendingToolUses.get(toolUseId) ?? null : null;
+      if (pending && toolUseId) {
+        input.pendingToolUses.delete(toolUseId);
+      }
+      logs.push({
+        id: toolUseId ? `${input.runId}-claude-tool-${toolUseId}` : normalizeString(input.record.uuid) ?? `${input.runId}-claude-${Date.now()}`,
+        runId: input.runId,
+        title: "Tool activity",
+        detail: JSON.stringify({
+          type: "claude_tool_activity",
+          session_id: normalizeString(input.record.sessionId) ?? normalizeString(input.record.session_id),
+          uuid: normalizeString(input.record.uuid),
+          tool_use_id: toolUseId,
+          tool_name: pending?.name ?? null,
+          tool_input: pending?.input ?? null,
+          tool_result: contentRecord.content ?? contentRecord,
+          is_error: contentRecord.is_error === true,
+          raw: {
+            toolUse: pending?.record ?? null,
+            toolResult: contentRecord
+          }
+        }),
+        tone: contentRecord.is_error === true ? "error" : "tool",
+        status: input.status,
+        payload: {
+          toolUseId,
+          toolName: pending?.name ?? null,
+          toolInput: pending?.input ?? null,
+          content: contentRecord.content ?? null,
+          isError: contentRecord.is_error === true
+        },
+        createdAt: pending?.timestamp ?? createdAt
+      });
+      continue;
+    }
+    if (!input.includeMessageLogs) {
+      continue;
+    }
+    logs.push({
+      id: normalizeString(input.record.uuid) ? `${normalizeString(input.record.uuid)}:${contentType ?? "content"}:${logs.length + 1}` : `${input.runId}-claude-${Date.now()}-${logs.length + 1}`,
+      runId: input.runId,
+      title: role === "assistant" ? "Assistant output" : role === "user" ? "Tool activity" : "Agent output",
+      detail: JSON.stringify({
+        type: role,
+        message: {
+          role,
+          content: [contentRecord]
+        },
+        session_id: normalizeString(input.record.sessionId) ?? normalizeString(input.record.session_id),
+        uuid: normalizeString(input.record.uuid)
+      }),
+      tone: contentType === "text" ? "info" : "tool",
+      status: input.status,
+      payload: contentRecord,
+      createdAt
+    });
+  }
+  return logs;
+}
+function flushPendingClaudeToolUseLogs(input) {
+  const logs = [];
+  for (const pending of input.pendingToolUses.values()) {
+    logs.push({
+      id: `${input.runId}-claude-tool-${pending.id}`,
+      runId: input.runId,
+      title: "Tool activity",
+      detail: JSON.stringify({
+        type: "claude_tool_use",
+        tool_use_id: pending.id,
+        tool_name: pending.name,
+        tool_input: pending.input,
+        raw: pending.record
+      }),
+      tone: "tool",
+      status: input.status,
+      payload: {
+        toolUseId: pending.id,
+        toolName: pending.name,
+        toolInput: pending.input
+      },
+      createdAt: pending.timestamp
+    });
+  }
+  input.pendingToolUses.clear();
+  return logs;
+}
+export {
+  flushPendingClaudeToolUseLogs,
+  buildClaudeLogsFromRecord
+};

package/dist/src/codex-app-server.d.ts

@@ -0,0 +1,16 @@
+export declare const CODEX_APP_SERVER_TASK_RUN_SENTINEL = "__rig_codex_app_server_task_run__";
+export type CodexAppServerTaskRunConfig = {
+    model?: string;
+    prompt: string;
+    runtimeMode: string;
+    interactionMode?: string;
+};
+export declare function buildCodexAppServerArgs(): string[];
+export declare function parseCodexAppServerTaskRunArgs(argv: string[]): CodexAppServerTaskRunConfig | null;
+export declare function runCodexAppServerTaskRun(options: {
+    codexBinary: string;
+    launchArgs: string[];
+    cwd: string;
+    env: Record<string, string | undefined>;
+    config: CodexAppServerTaskRunConfig;
+}): Promise<number>;

package/dist/src/codex-app-server.js

@@ -0,0 +1,548 @@
+// @bun
+// packages/provider-plugin/src/codex-app-server.ts
+import { spawn } from "child_process";
+import { createInterface } from "readline";
+import { invokeRuntimeTool, CLAUDE_ROUTER_TOOL_DEFINITIONS } from "@rig/runtime/control-plane/runtime/tooling/claude-router";
+var CODEX_APP_SERVER_TASK_RUN_SENTINEL = "__rig_codex_app_server_task_run__";
+var RIG_DYNAMIC_TOOL_SERVER = "rig_runtime_tools";
+var DEFAULT_CLIENT_INFO = {
+  name: "rig_task_runtime",
+  title: "Rig Task Runtime",
+  version: "0.1.0"
+};
+var CODEX_APP_SERVER_DISABLED_FEATURES = [
+  "shell_tool",
+  "apply_patch_freeform",
+  "request_permissions_tool",
+  "apps",
+  "plugins",
+  "tool_search",
+  "js_repl",
+  "js_repl_tools_only",
+  "collab"
+];
+function buildCodexAppServerArgs() {
+  return [
+    "app-server",
+    ...CODEX_APP_SERVER_DISABLED_FEATURES.flatMap((feature) => ["--disable", feature]),
+    "-c",
+    'web_search="disabled"',
+    "-c",
+    "tools.view_image=false",
+    "-c",
+    "features.default_mode_request_user_input=false"
+  ];
+}
+function parseCodexAppServerTaskRunArgs(argv) {
+  if (argv[0] !== CODEX_APP_SERVER_TASK_RUN_SENTINEL) {
+    return null;
+  }
+  let model;
+  let prompt;
+  let runtimeMode = "workspace-write";
+  let interactionMode;
+  for (let index = 1;index < argv.length; index += 1) {
+    const current = argv[index];
+    if (current === "--model") {
+      model = argv[index + 1];
+      index += 1;
+      continue;
+    }
+    if (current === "--runtime-mode") {
+      runtimeMode = argv[index + 1] ?? runtimeMode;
+      index += 1;
+      continue;
+    }
+    if (current === "--interaction-mode") {
+      interactionMode = argv[index + 1];
+      index += 1;
+      continue;
+    }
+    if (current === "--prompt") {
+      prompt = argv[index + 1];
+      index += 1;
+      continue;
+    }
+  }
+  if (!prompt?.trim()) {
+    throw new Error("Missing `--prompt` for Codex app-server task run.");
+  }
+  return {
+    model: model?.trim() ? model.trim() : undefined,
+    prompt,
+    runtimeMode,
+    interactionMode
+  };
+}
+async function runCodexAppServerTaskRun(options) {
+  const child = spawn(options.codexBinary, options.launchArgs, {
+    cwd: options.cwd,
+    env: sanitizeEnv(options.env),
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  const pendingResponses = new Map;
+  const dynamicToolResults = new Map;
+  const agentMessageText = new Map;
+  const inFlightToolCalls = new Set;
+  let nextRequestId = 1;
+  let sendQueue = Promise.resolve();
+  const completionState = { current: null };
+  const stdout = createInterface({ input: child.stdout });
+  const stderr = createInterface({ input: child.stderr });
+  const sendMessage = (payload) => {
+    const line = `${JSON.stringify(payload)}
+`;
+    sendQueue = sendQueue.then(() => writeChildLine(child, line));
+    return sendQueue;
+  };
+  const sendRequest = async (method, params) => {
+    const id = nextRequestId;
+    nextRequestId += 1;
+    const resultPromise = new Promise((resolve, reject) => {
+      pendingResponses.set(id, { resolve, reject });
+    });
+    await sendMessage({ id, method, params });
+    return resultPromise;
+  };
+  const sendResponse = async (id, result) => {
+    await sendMessage({ id, result });
+  };
+  const sendError = async (id, message) => {
+    await sendMessage({
+      id,
+      error: {
+        code: -32603,
+        message
+      }
+    });
+  };
+  const trackToolCall = (call) => {
+    inFlightToolCalls.add(call);
+    call.finally(() => inFlightToolCalls.delete(call)).catch((err) => {
+      console.warn("[codex-app-server] in-flight tool call failure:", err);
+    });
+  };
+  const handleNotification = (message) => {
+    const method = message.method;
+    if (!method) {
+      return;
+    }
+    const params = message.params ?? {};
+    const timestamp = new Date().toISOString();
+    if (method === "thread/started") {
+      emitSyntheticCodexRecord({
+        type: "thread.started",
+        timestamp,
+        thread: params.thread ?? null
+      });
+      return;
+    }
+    if (method === "turn/started") {
+      emitSyntheticCodexRecord({
+        type: "turn.started",
+        timestamp,
+        turn: params.turn ?? null
+      });
+      return;
+    }
+    if (method === "item/agentMessage/delta") {
+      const itemId = normalizeString(params.itemId);
+      const delta = typeof params.delta === "string" ? params.delta : "";
+      if (!itemId || delta.length === 0) {
+        return;
+      }
+      agentMessageText.set(itemId, `${agentMessageText.get(itemId) ?? ""}${delta}`);
+      emitSyntheticCodexRecord({
+        type: "stream_event",
+        event: {
+          delta: {
+            type: "text_delta",
+            text: delta
+          }
+        }
+      });
+      return;
+    }
+    if (method === "item/started" || method === "item/completed") {
+      const record = mapAppServerItemToCodexRecord({
+        phase: method === "item/started" ? "item.started" : "item.completed",
+        timestamp,
+        item: params.item,
+        dynamicToolResults,
+        agentMessageText
+      });
+      if (record) {
+        emitSyntheticCodexRecord(record);
+      }
+      return;
+    }
+    if (method === "turn/completed") {
+      const turn = asRecord(params.turn);
+      const error = asRecord(turn?.error);
+      completionState.current = {
+        status: normalizeString(turn?.status) ?? "failed",
+        error: normalizeString(error?.message)
+      };
+      emitSyntheticCodexRecord({
+        type: "turn.completed",
+        timestamp,
+        turn
+      });
+      return;
+    }
+    if (method === "error") {
+      const errorMessage = normalizeString(params.message) ?? JSON.stringify(params);
+      console.error(`[rig-codex-app-server] ${errorMessage}`);
+    }
+  };
+  const handleServerRequest = (message) => {
+    const method = message.method;
+    const requestId = message.id;
+    if (!method || requestId === undefined) {
+      return;
+    }
+    if (method === "item/tool/call") {
+      const params = message.params ?? {};
+      const callId = normalizeString(params.callId);
+      const toolName = normalizeString(params.tool);
+      const toolArgs = asRecord(params.arguments) ?? {};
+      const toolCall = (async () => {
+        if (!callId || !toolName) {
+          await sendError(requestId, "Malformed dynamic tool call.");
+          return;
+        }
+        try {
+          const invocation = await invokeRuntimeTool(toolName, toolArgs, {
+            env: options.env
+          });
+          const contentItems = invocationToContentItems(invocation);
+          const contentText = contentItems.filter((item) => item.type === "inputText").map((item) => item.text).join(`
+`).trim();
+          dynamicToolResults.set(callId, {
+            isError: invocation.isError === true,
+            contentText,
+            structuredResult: asRecord(invocation.structuredContent) ?? (contentText ? { content: contentText } : null)
+          });
+          await sendResponse(requestId, {
+            contentItems,
+            success: invocation.isError !== true
+          });
+        } catch (error) {
+          const messageText = error instanceof Error ? error.message : String(error);
+          dynamicToolResults.set(callId, {
+            isError: true,
+            contentText: messageText,
+            structuredResult: { error: messageText }
+          });
+          await sendResponse(requestId, {
+            contentItems: [{ type: "inputText", text: messageText }],
+            success: false
+          });
+        }
+      })();
+      trackToolCall(toolCall);
+      return;
+    }
+    if (method === "item/commandExecution/requestApproval" || method === "item/fileChange/requestApproval") {
+      trackToolCall(sendResponse(requestId, { decision: "decline" }));
+      return;
+    }
+    if (method === "item/permissions/requestApproval") {
+      trackToolCall(sendResponse(requestId, {
+        permissions: {},
+        scope: "turn"
+      }));
+      return;
+    }
+    if (method === "applyPatchApproval" || method === "execCommandApproval") {
+      trackToolCall(sendResponse(requestId, { decision: "denied" }));
+      return;
+    }
+    trackToolCall(sendError(requestId, `Unsupported app-server request: ${method}`));
+  };
+  stdout.on("line", (line) => {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      return;
+    }
+    let message;
+    try {
+      message = JSON.parse(trimmed);
+    } catch {
+      console.error(trimmed);
+      return;
+    }
+    if (message.method) {
+      if (message.id !== undefined) {
+        handleServerRequest(message);
+      } else {
+        handleNotification(message);
+      }
+      return;
+    }
+    if (message.id !== undefined) {
+      const pending = pendingResponses.get(message.id);
+      if (!pending) {
+        return;
+      }
+      pendingResponses.delete(message.id);
+      if (message.error) {
+        pending.reject(new Error(formatJsonRpcError(message.error)));
+      } else {
+        pending.resolve(message.result ?? {});
+      }
+    }
+  });
+  stderr.on("line", (line) => {
+    if (line.trim()) {
+      console.error(line);
+    }
+  });
+  const exitPromise = new Promise((resolve) => {
+    child.once("close", (code, signal) => resolve({ code, signal }));
+  });
+  await sendRequest("initialize", {
+    clientInfo: DEFAULT_CLIENT_INFO,
+    capabilities: {
+      experimentalApi: true
+    }
+  });
+  await sendMessage({
+    method: "initialized",
+    params: {}
+  });
+  const threadStart = await sendRequest("thread/start", {
+    model: options.config.model ?? null,
+    cwd: options.cwd,
+    approvalPolicy: "never",
+    sandbox: options.config.runtimeMode === "full-access" ? "danger-full-access" : "workspace-write",
+    serviceName: "rig_task_runtime",
+    experimentalRawEvents: false,
+    persistExtendedHistory: false,
+    dynamicTools: codexDynamicToolDefinitions()
+  });
+  const thread = asRecord(threadStart.thread);
+  const threadId = normalizeString(thread?.id);
+  if (!threadId) {
+    throw new Error("Codex app-server thread/start did not return a thread id.");
+  }
+  await sendRequest("turn/start", {
+    threadId,
+    input: [
+      {
+        type: "text",
+        text: options.config.prompt,
+        text_elements: []
+      }
+    ]
+  });
+  let exitResult = null;
+  while (!completionState.current) {
+    exitResult = await Promise.race([
+      exitPromise,
+      new Promise((resolve) => setTimeout(() => resolve(null), 100))
+    ]);
+    if (exitResult) {
+      break;
+    }
+  }
+  const completedTurn = completionState.current;
+  if (!completedTurn) {
+    const detail = exitResult ? `codex app-server exited before turn completion (${String(exitResult.code ?? exitResult.signal ?? "unknown")})` : "codex app-server exited before turn completion";
+    throw new Error(detail);
+  }
+  if (inFlightToolCalls.size > 0) {
+    await Promise.allSettled(Array.from(inFlightToolCalls));
+  }
+  terminateChild(child);
+  await exitPromise;
+  if (completedTurn.status !== "completed") {
+    const reason = completedTurn.error ?? `Codex turn ended with status ${completedTurn.status}`;
+    console.error(`[rig-codex-app-server] ${reason}`);
+    return 1;
+  }
+  return 0;
+}
+function codexDynamicToolDefinitions() {
+  return [
+    {
+      name: "shell",
+      description: "Run a shell command through Rig's audited gateway inside the current task workspace. Use this for git, bun, node, python3, rg, and related command-line work. Never rely on absolute host binaries.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          command: { type: "string", description: "Shell command to execute." },
+          workdir: { type: "string", description: "Optional workspace-relative working directory." },
+          shell: { type: "string", enum: ["bash", "sh", "zsh"] }
+        },
+        required: ["command"],
+        additionalProperties: false
+      }
+    },
+    ...CLAUDE_ROUTER_TOOL_DEFINITIONS
+  ];
+}
+function mapAppServerItemToCodexRecord(input) {
+  const item = asRecord(input.item);
+  const itemType = normalizeString(item?.type);
+  const itemId = normalizeString(item?.id);
+  if (!item || !itemType || !itemId) {
+    return null;
+  }
+  if (itemType === "agentMessage") {
+    if (input.phase !== "item.completed") {
+      return null;
+    }
+    const finalText = normalizeString(item.text) ?? input.agentMessageText.get(itemId) ?? "";
+    input.agentMessageText.delete(itemId);
+    return {
+      type: "item.completed",
+      timestamp: input.timestamp,
+      item: {
+        id: itemId,
+        type: "agent_message",
+        text: finalText
+      }
+    };
+  }
+  if (itemType === "commandExecution") {
+    return {
+      type: input.phase,
+      timestamp: input.timestamp,
+      item: {
+        id: itemId,
+        type: "command_execution",
+        command: normalizeString(item.command),
+        cwd: normalizeString(item.cwd),
+        status: normalizeStatus(item.status),
+        aggregated_output: normalizeString(item.aggregatedOutput),
+        exit_code: typeof item.exitCode === "number" ? item.exitCode : null,
+        duration_ms: typeof item.durationMs === "number" ? item.durationMs : null
+      }
+    };
+  }
+  if (itemType === "mcpToolCall") {
+    return {
+      type: input.phase,
+      timestamp: input.timestamp,
+      item: {
+        id: itemId,
+        type: "mcp_tool_call",
+        server: normalizeString(item.server),
+        tool: normalizeString(item.tool),
+        status: normalizeStatus(item.status),
+        arguments: item.arguments ?? null,
+        result: asRecord(item.result) ?? null,
+        error: asRecord(item.error) ?? null
+      }
+    };
+  }
+  if (itemType === "dynamicToolCall") {
+    const cached = input.dynamicToolResults.get(itemId) ?? null;
+    if (input.phase === "item.completed") {
+      input.dynamicToolResults.delete(itemId);
+    }
+    return {
+      type: input.phase,
+      timestamp: input.timestamp,
+      item: {
+        id: itemId,
+        type: "mcp_tool_call",
+        server: RIG_DYNAMIC_TOOL_SERVER,
+        tool: normalizeString(item.tool),
+        status: cached?.isError ? "failed" : normalizeStatus(item.status),
+        arguments: item.arguments ?? null,
+        result: cached?.structuredResult ?? {
+          content_items: item.contentItems ?? null,
+          success: item.success ?? null
+        }
+      }
+    };
+  }
+  return null;
+}
+function invocationToContentItems(invocation) {
+  const items = Array.isArray(invocation.content) ? invocation.content : [];
+  const mapped = items.map((item) => {
+    const entry = asRecord(item);
+    if (!entry || entry.type !== "text" || typeof entry.text !== "string") {
+      return null;
+    }
+    return {
+      type: "inputText",
+      text: entry.text
+    };
+  }).filter((item) => Boolean(item));
+  return mapped.length > 0 ? mapped : [{ type: "inputText", text: "(empty tool response)" }];
+}
+function emitSyntheticCodexRecord(record) {
+  process.stdout.write(`${JSON.stringify(record)}
+`);
+}
+function sanitizeEnv(env) {
+  const next = {};
+  for (const [key, value] of Object.entries(env)) {
+    if (typeof value === "string") {
+      next[key] = value;
+    }
+  }
+  return next;
+}
+function writeChildLine(child, line) {
+  return new Promise((resolve, reject) => {
+    child.stdin.write(line, (error) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve();
+    });
+  });
+}
+function terminateChild(child) {
+  if (child.killed) {
+    return;
+  }
+  try {
+    child.kill("SIGTERM");
+  } catch {}
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function normalizeString(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function normalizeStatus(value) {
+  const raw = normalizeString(value);
+  if (!raw) {
+    return null;
+  }
+  switch (raw) {
+    case "inProgress":
+      return "in_progress";
+    case "completed":
+    case "failed":
+    case "declined":
+      return raw;
+    default:
+      return raw;
+  }
+}
+function formatJsonRpcError(error) {
+  if (!error) {
+    return "Unknown app-server error";
+  }
+  const parts = [error.message, error.data ? JSON.stringify(error.data) : null].filter(Boolean);
+  return parts.join(" ");
+}
+export {
+  runCodexAppServerTaskRun,
+  parseCodexAppServerTaskRunArgs,
+  buildCodexAppServerArgs,
+  CODEX_APP_SERVER_TASK_RUN_SENTINEL
+};

package/dist/src/codex-exec-records.d.ts

@@ -0,0 +1,27 @@
+import type { EngineRunLog } from "@rig/contracts";
+type CodexStreamStatus = EngineRunLog["status"];
+export type PendingCodexToolUse = {
+    id: string;
+    itemType: "command_execution" | "mcp_tool_call";
+    name: string | null;
+    input: unknown;
+    timestamp: string;
+    record: Record<string, unknown>;
+};
+type BuildCodexLogsFromRecordInput = {
+    runId: string;
+    record: Record<string, unknown>;
+    createdAtFallback: string;
+    status: CodexStreamStatus;
+    pendingToolUses: Map<string, PendingCodexToolUse>;
+    includeMessageLogs?: boolean;
+};
+export declare function isCodexExecRecord(record: Record<string, unknown>): boolean;
+export declare function extractCodexAssistantMessageText(record: Record<string, unknown>): string | null;
+export declare function buildCodexLogsFromRecord(input: BuildCodexLogsFromRecordInput): EngineRunLog[];
+export declare function flushPendingCodexToolUseLogs(input: {
+    runId: string;
+    status: CodexStreamStatus;
+    pendingToolUses: Map<string, PendingCodexToolUse>;
+}): EngineRunLog[];
+export {};

package/dist/src/codex-exec-records.js

@@ -0,0 +1,203 @@
+// @bun
+// packages/provider-plugin/src/codex-exec-records.ts
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function normalizeString(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function normalizeIsoTimestamp(value) {
+  const normalized = normalizeString(value);
+  if (!normalized) {
+    return null;
+  }
+  const timestamp = Date.parse(normalized);
+  return Number.isNaN(timestamp) ? null : new Date(timestamp).toISOString();
+}
+function isCodexExecRecord(record) {
+  const type = normalizeString(record.type);
+  return type === "thread.started" || type === "thread.completed" || type === "turn.started" || type === "turn.completed" || type === "item.started" || type === "item.completed";
+}
+function extractCodexAssistantMessageText(record) {
+  if (normalizeString(record.type) !== "item.completed") {
+    return null;
+  }
+  const item = asRecord(record.item);
+  if (!item || normalizeString(item.type) !== "agent_message") {
+    return null;
+  }
+  return normalizeString(item.text);
+}
+function codexToolName(itemType, item) {
+  if (itemType === "command_execution") {
+    return "Bash";
+  }
+  const server = normalizeString(item.server);
+  const tool = normalizeString(item.tool);
+  if (server && tool) {
+    return `mcp__${server}__${tool}`;
+  }
+  return tool;
+}
+function codexToolInput(itemType, item) {
+  if (itemType === "command_execution") {
+    return {
+      command: normalizeString(item.command)
+    };
+  }
+  return item.arguments ?? item.input ?? null;
+}
+function codexToolResult(itemType, item) {
+  if (itemType === "command_execution") {
+    return {
+      command: normalizeString(item.command),
+      stdout: normalizeString(item.aggregated_output),
+      exit_code: typeof item.exit_code === "number" ? item.exit_code : null,
+      status: normalizeString(item.status)
+    };
+  }
+  const error = asRecord(item.error);
+  if (error) {
+    return {
+      content: normalizeString(error.message) ?? JSON.stringify(error),
+      error
+    };
+  }
+  return item.result ?? item.output ?? item;
+}
+function codexToolError(itemType, item) {
+  if (itemType === "command_execution") {
+    return typeof item.exit_code === "number" && item.exit_code !== 0 || normalizeString(item.status) === "failed";
+  }
+  return item.error != null || normalizeString(item.status) === "failed";
+}
+function buildCodexLogsFromRecord(input) {
+  const entryType = normalizeString(input.record.type);
+  if (entryType !== "item.started" && entryType !== "item.completed") {
+    return [];
+  }
+  const item = asRecord(input.record.item);
+  if (!item) {
+    return [];
+  }
+  const itemTypeRaw = normalizeString(item.type);
+  const itemType = itemTypeRaw === "command_execution" || itemTypeRaw === "mcp_tool_call" ? itemTypeRaw : null;
+  const createdAt = normalizeIsoTimestamp(input.record.timestamp) ?? input.createdAtFallback;
+  if (!itemType) {
+    if (itemTypeRaw === "agent_message" && input.includeMessageLogs) {
+      const text = normalizeString(item.text);
+      if (!text) {
+        return [];
+      }
+      return [{
+        id: normalizeString(item.id) ?? `${input.runId}-codex-message-${Date.now()}`,
+        runId: input.runId,
+        title: "Assistant output",
+        detail: JSON.stringify({
+          type: "assistant",
+          message: {
+            role: "assistant",
+            content: [{ type: "text", text }]
+          }
+        }),
+        tone: "info",
+        status: input.status,
+        payload: { text },
+        createdAt
+      }];
+    }
+    return [];
+  }
+  const itemId = normalizeString(item.id);
+  if (!itemId) {
+    return [];
+  }
+  if (entryType === "item.started") {
+    input.pendingToolUses.set(itemId, {
+      id: itemId,
+      itemType,
+      name: codexToolName(itemType, item),
+      input: codexToolInput(itemType, item),
+      timestamp: createdAt,
+      record: item
+    });
+    return [];
+  }
+  const pending = input.pendingToolUses.get(itemId) ?? null;
+  if (pending) {
+    input.pendingToolUses.delete(itemId);
+  }
+  const toolName = pending?.name ?? codexToolName(itemType, item);
+  const toolInput = pending?.input ?? codexToolInput(itemType, item);
+  const toolResult = codexToolResult(itemType, item);
+  const isError = codexToolError(itemType, item);
+  const stdout = asRecord(toolResult)?.stdout;
+  return [{
+    id: `${input.runId}-codex-tool-${itemId}`,
+    runId: input.runId,
+    title: "Tool activity",
+    detail: JSON.stringify({
+      type: "agent_tool_activity",
+      provider: "codex",
+      item_type: itemType,
+      tool_use_id: itemId,
+      tool_name: toolName,
+      tool_input: toolInput,
+      tool_result: toolResult,
+      is_error: isError,
+      raw: {
+        started: pending?.record ?? null,
+        completed: item
+      }
+    }),
+    tone: isError ? "error" : "tool",
+    status: input.status,
+    payload: {
+      toolUseId: itemId,
+      toolName,
+      toolInput,
+      content: typeof stdout === "string" ? stdout : null,
+      isError
+    },
+    createdAt: pending?.timestamp ?? createdAt
+  }];
+}
+function flushPendingCodexToolUseLogs(input) {
+  const logs = [];
+  for (const pending of input.pendingToolUses.values()) {
+    logs.push({
+      id: `${input.runId}-codex-tool-${pending.id}`,
+      runId: input.runId,
+      title: "Tool activity",
+      detail: JSON.stringify({
+        type: "agent_tool_use",
+        provider: "codex",
+        item_type: pending.itemType,
+        tool_use_id: pending.id,
+        tool_name: pending.name,
+        tool_input: pending.input,
+        raw: pending.record
+      }),
+      tone: "tool",
+      status: input.status,
+      payload: {
+        toolUseId: pending.id,
+        toolName: pending.name,
+        toolInput: pending.input
+      },
+      createdAt: pending.timestamp
+    });
+  }
+  input.pendingToolUses.clear();
+  return logs;
+}
+export {
+  isCodexExecRecord,
+  flushPendingCodexToolUseLogs,
+  extractCodexAssistantMessageText,
+  buildCodexLogsFromRecord
+};

package/dist/src/index.d.ts

@@ -0,0 +1,5 @@
+export { providerPlugin, createProviderPlugin, PROVIDER_PLUGIN_NAME, } from "./plugin";
+export { runtimeInstructionService, svc } from "./service";
+export { normalizeRuntimeInstructionProvider, buildProviderTaskRunInstructionLines, buildProviderRuntimeContextLines, } from "./runtime-instructions";
+export { loadRigTaskRunSkillBody } from "./rig-task-run-skill";
+export { default } from "./plugin";

package/dist/src/index.js

@@ -0,0 +1,127 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// packages/provider-plugin/src/runtime-instructions.ts
+function normalizeRuntimeInstructionProvider(_value) {
+  return "pi";
+}
+function buildProviderTaskRunInstructionLines(_provider) {
+  return [
+    "Use Pi's built-in `read`, `write`, `edit`, and `bash` tools from the isolated Rig task worktree.",
+    "Keep file writes inside the scoped task workspace unless Rig explicitly tells you a path is host/project metadata.",
+    "Prefer `read`, `write`, and `edit` over shell one-liners whenever those tools fit.",
+    "When shell access is needed, keep commands narrow and bounded; avoid repo-wide searches without an explicit path and output cap."
+  ];
+}
+function buildProviderRuntimeContextLines(_provider) {
+  return [
+    "Pi runs from the isolated Rig task worktree with its built-in `read`, `write`, `edit`, and `bash` tools enabled.",
+    "Keep writes scoped to the task workspace unless Rig-provided instructions name an explicit metadata path.",
+    "Prefer Pi file tools over shell one-liners for file reads and edits.",
+    "Keep shell commands narrow and bounded; cap broad searches before widening."
+  ];
+}
+
+// packages/provider-plugin/src/service.ts
+var exports_service = {};
+__export(exports_service, {
+  svc: () => svc,
+  runtimeInstructionService: () => runtimeInstructionService
+});
+var svc, runtimeInstructionService;
+var init_service = __esm(() => {
+  svc = {
+    normalizeProvider: normalizeRuntimeInstructionProvider,
+    buildTaskRunInstructionLines: buildProviderTaskRunInstructionLines,
+    buildRuntimeContextLines: buildProviderRuntimeContextLines
+  };
+  runtimeInstructionService = svc;
+});
+
+// packages/provider-plugin/src/plugin.ts
+import { definePlugin } from "@rig/core/config";
+import { RUNTIME_INSTRUCTION_SERVICE_CAPABILITY_ID } from "@rig/contracts";
+var PROVIDER_PLUGIN_NAME = "@rig/provider-plugin";
+var providerPlugin = definePlugin({
+  name: PROVIDER_PLUGIN_NAME,
+  version: "0.0.0-alpha.1",
+  contributes: {
+    capabilities: [
+      {
+        id: RUNTIME_INSTRUCTION_SERVICE_CAPABILITY_ID,
+        title: "Agent harness provider instructions",
+        description: "Provide the agent-harness file-tool contract and runtime-context instruction lines.",
+        run: async () => (await Promise.resolve().then(() => (init_service(), exports_service))).svc
+      }
+    ]
+  }
+});
+function createProviderPlugin() {
+  return providerPlugin;
+}
+var plugin_default = providerPlugin;
+
+// packages/provider-plugin/src/index.ts
+init_service();
+
+// packages/provider-plugin/src/rig-task-run-skill.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+var SKILL_FILENAME = "rig-task-run.md";
+var FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+var cachedBody = null;
+function loadRigTaskRunSkillBody() {
+  if (cachedBody !== null) {
+    return cachedBody;
+  }
+  const path = resolveSkillPath();
+  if (!path) {
+    cachedBody = "";
+    return cachedBody;
+  }
+  const raw = readFileSync(path, "utf-8");
+  const match = raw.match(FRONTMATTER_RE);
+  cachedBody = (match ? match[2] ?? raw : raw).trim();
+  return cachedBody;
+}
+function resolveSkillPath() {
+  const here = dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    resolve(here, "..", "skills", SKILL_FILENAME),
+    resolve(here, "..", "..", "skills", SKILL_FILENAME),
+    resolve(here, "..", "..", "..", "skills", SKILL_FILENAME)
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+export {
+  svc,
+  runtimeInstructionService,
+  providerPlugin,
+  normalizeRuntimeInstructionProvider,
+  loadRigTaskRunSkillBody,
+  plugin_default as default,
+  createProviderPlugin,
+  buildProviderTaskRunInstructionLines,
+  buildProviderRuntimeContextLines,
+  PROVIDER_PLUGIN_NAME
+};

package/dist/src/plugin.d.ts

@@ -0,0 +1,4 @@
+export declare const PROVIDER_PLUGIN_NAME = "@rig/provider-plugin";
+export declare const providerPlugin: import("@rig/core").RigPlugin;
+export declare function createProviderPlugin(): import("@rig/core").RigPlugin;
+export default providerPlugin;

package/dist/src/plugin.js

@@ -0,0 +1,82 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// packages/provider-plugin/src/runtime-instructions.ts
+function normalizeRuntimeInstructionProvider(_value) {
+  return "pi";
+}
+function buildProviderTaskRunInstructionLines(_provider) {
+  return [
+    "Use Pi's built-in `read`, `write`, `edit`, and `bash` tools from the isolated Rig task worktree.",
+    "Keep file writes inside the scoped task workspace unless Rig explicitly tells you a path is host/project metadata.",
+    "Prefer `read`, `write`, and `edit` over shell one-liners whenever those tools fit.",
+    "When shell access is needed, keep commands narrow and bounded; avoid repo-wide searches without an explicit path and output cap."
+  ];
+}
+function buildProviderRuntimeContextLines(_provider) {
+  return [
+    "Pi runs from the isolated Rig task worktree with its built-in `read`, `write`, `edit`, and `bash` tools enabled.",
+    "Keep writes scoped to the task workspace unless Rig-provided instructions name an explicit metadata path.",
+    "Prefer Pi file tools over shell one-liners for file reads and edits.",
+    "Keep shell commands narrow and bounded; cap broad searches before widening."
+  ];
+}
+
+// packages/provider-plugin/src/service.ts
+var exports_service = {};
+__export(exports_service, {
+  svc: () => svc,
+  runtimeInstructionService: () => runtimeInstructionService
+});
+var svc, runtimeInstructionService;
+var init_service = __esm(() => {
+  svc = {
+    normalizeProvider: normalizeRuntimeInstructionProvider,
+    buildTaskRunInstructionLines: buildProviderTaskRunInstructionLines,
+    buildRuntimeContextLines: buildProviderRuntimeContextLines
+  };
+  runtimeInstructionService = svc;
+});
+
+// packages/provider-plugin/src/plugin.ts
+import { definePlugin } from "@rig/core/config";
+import { RUNTIME_INSTRUCTION_SERVICE_CAPABILITY_ID } from "@rig/contracts";
+var PROVIDER_PLUGIN_NAME = "@rig/provider-plugin";
+var providerPlugin = definePlugin({
+  name: PROVIDER_PLUGIN_NAME,
+  version: "0.0.0-alpha.1",
+  contributes: {
+    capabilities: [
+      {
+        id: RUNTIME_INSTRUCTION_SERVICE_CAPABILITY_ID,
+        title: "Agent harness provider instructions",
+        description: "Provide the agent-harness file-tool contract and runtime-context instruction lines.",
+        run: async () => (await Promise.resolve().then(() => (init_service(), exports_service))).svc
+      }
+    ]
+  }
+});
+function createProviderPlugin() {
+  return providerPlugin;
+}
+var plugin_default = providerPlugin;
+export {
+  providerPlugin,
+  plugin_default as default,
+  createProviderPlugin,
+  PROVIDER_PLUGIN_NAME
+};

package/dist/src/rig-task-run-skill.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Return the rig-task-run skill body (markdown without frontmatter).
+ *
+ * The file is shipped at `packages/runtime/skills/rig-task-run.md`. We search
+ * a few paths so it resolves whether the caller is running from monorepo
+ * source, from a sibling import, or via the published @rig/runtime exports.
+ */
+export declare function loadRigTaskRunSkillBody(): string;

package/dist/src/rig-task-run-skill.js

@@ -0,0 +1,39 @@
+// @bun
+// packages/provider-plugin/src/rig-task-run-skill.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+var SKILL_FILENAME = "rig-task-run.md";
+var FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+var cachedBody = null;
+function loadRigTaskRunSkillBody() {
+  if (cachedBody !== null) {
+    return cachedBody;
+  }
+  const path = resolveSkillPath();
+  if (!path) {
+    cachedBody = "";
+    return cachedBody;
+  }
+  const raw = readFileSync(path, "utf-8");
+  const match = raw.match(FRONTMATTER_RE);
+  cachedBody = (match ? match[2] ?? raw : raw).trim();
+  return cachedBody;
+}
+function resolveSkillPath() {
+  const here = dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    resolve(here, "..", "skills", SKILL_FILENAME),
+    resolve(here, "..", "..", "skills", SKILL_FILENAME),
+    resolve(here, "..", "..", "..", "skills", SKILL_FILENAME)
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+export {
+  loadRigTaskRunSkillBody
+};

package/dist/src/runtime-instructions.d.ts

@@ -0,0 +1,4 @@
+export type RuntimeInstructionProvider = "pi";
+export declare function normalizeRuntimeInstructionProvider(_value: string | undefined | null): RuntimeInstructionProvider;
+export declare function buildProviderTaskRunInstructionLines(_provider: RuntimeInstructionProvider): string[];
+export declare function buildProviderRuntimeContextLines(_provider: RuntimeInstructionProvider): string[];

package/dist/src/runtime-instructions.js

@@ -0,0 +1,26 @@
+// @bun
+// packages/provider-plugin/src/runtime-instructions.ts
+function normalizeRuntimeInstructionProvider(_value) {
+  return "pi";
+}
+function buildProviderTaskRunInstructionLines(_provider) {
+  return [
+    "Use Pi's built-in `read`, `write`, `edit`, and `bash` tools from the isolated Rig task worktree.",
+    "Keep file writes inside the scoped task workspace unless Rig explicitly tells you a path is host/project metadata.",
+    "Prefer `read`, `write`, and `edit` over shell one-liners whenever those tools fit.",
+    "When shell access is needed, keep commands narrow and bounded; avoid repo-wide searches without an explicit path and output cap."
+  ];
+}
+function buildProviderRuntimeContextLines(_provider) {
+  return [
+    "Pi runs from the isolated Rig task worktree with its built-in `read`, `write`, `edit`, and `bash` tools enabled.",
+    "Keep writes scoped to the task workspace unless Rig-provided instructions name an explicit metadata path.",
+    "Prefer Pi file tools over shell one-liners for file reads and edits.",
+    "Keep shell commands narrow and bounded; cap broad searches before widening."
+  ];
+}
+export {
+  normalizeRuntimeInstructionProvider,
+  buildProviderTaskRunInstructionLines,
+  buildProviderRuntimeContextLines
+};

package/dist/src/service.d.ts

@@ -0,0 +1,14 @@
+/**
+ * service.ts — the concrete agent-harness instruction service the runtime port
+ * resolves and consumes.
+ *
+ * CONFIG-LIGHT: this module top-level-imports the instruction-builder impl. It
+ * is loaded LAZILY by the capability `run()` in plugin.ts
+ * (`(await import("./service")).svc`), so merely evaluating rig.config.ts never
+ * drags the provider impl into scope.
+ */
+import type { RuntimeInstructionService } from "@rig/runtime/control-plane/provider-instruction-port";
+/** The concrete agent-harness instruction service the runtime port resolves. */
+export declare const svc: RuntimeInstructionService;
+/** Back-compat alias. */
+export declare const runtimeInstructionService: RuntimeInstructionService;

package/dist/src/service.js

@@ -0,0 +1,33 @@
+// @bun
+// packages/provider-plugin/src/runtime-instructions.ts
+function normalizeRuntimeInstructionProvider(_value) {
+  return "pi";
+}
+function buildProviderTaskRunInstructionLines(_provider) {
+  return [
+    "Use Pi's built-in `read`, `write`, `edit`, and `bash` tools from the isolated Rig task worktree.",
+    "Keep file writes inside the scoped task workspace unless Rig explicitly tells you a path is host/project metadata.",
+    "Prefer `read`, `write`, and `edit` over shell one-liners whenever those tools fit.",
+    "When shell access is needed, keep commands narrow and bounded; avoid repo-wide searches without an explicit path and output cap."
+  ];
+}
+function buildProviderRuntimeContextLines(_provider) {
+  return [
+    "Pi runs from the isolated Rig task worktree with its built-in `read`, `write`, `edit`, and `bash` tools enabled.",
+    "Keep writes scoped to the task workspace unless Rig-provided instructions name an explicit metadata path.",
+    "Prefer Pi file tools over shell one-liners for file reads and edits.",
+    "Keep shell commands narrow and bounded; cap broad searches before widening."
+  ];
+}
+
+// packages/provider-plugin/src/service.ts
+var svc = {
+  normalizeProvider: normalizeRuntimeInstructionProvider,
+  buildTaskRunInstructionLines: buildProviderTaskRunInstructionLines,
+  buildRuntimeContextLines: buildProviderRuntimeContextLines
+};
+var runtimeInstructionService = svc;
+export {
+  svc,
+  runtimeInstructionService
+};

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@h-rig/provider-plugin",
+  "version": "0.0.6-alpha.156",
+  "type": "module",
+  "description": "First-party agent-harness provider capability plugin for Rig.",
+  "license": "UNLICENSED",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/src/plugin.d.ts",
+      "import": "./dist/src/plugin.js"
+    },
+    "./plugin": {
+      "types": "./dist/src/plugin.d.ts",
+      "import": "./dist/src/plugin.js"
+    },
+    "./index": {
+      "types": "./dist/src/index.d.ts",
+      "import": "./dist/src/index.js"
+    }
+  },
+  "engines": {
+    "bun": ">=1.3.11"
+  },
+  "main": "./dist/src/index.js",
+  "module": "./dist/src/index.js",
+  "types": "./dist/src/index.d.ts",
+  "dependencies": {
+    "@rig/contracts": "npm:@h-rig/contracts@0.0.6-alpha.156",
+    "@rig/core": "npm:@h-rig/core@0.0.6-alpha.156",
+    "@rig/runtime": "npm:@h-rig/runtime@0.0.6-alpha.156"
+  }
+}