@workflow-code/cli 0.2.0 → 0.2.3-20260901001

package/dist/openai-responses-runner-2MPK3UAP.js

@@ -0,0 +1,210 @@
+#!/usr/bin/env node
+import {
+  isolateOpenAIRunnerStdout
+} from "./chunk-OLNPMIEF.js";
+import "./chunk-NSPRIPOP.js";
+
+// src/openai-responses-runner.ts
+import { readFileSync } from "fs";
+import {
+  inspectLocalWorkflowStructure,
+  isOutputItemStreamChunk,
+  runLocalWorkflowWithReport
+} from "workflow-code";
+
+// .shared/openai-responses/index.ts
+var OPENAI_RESPONSE_RETENTION_MS = 30 * 24 * 60 * 60 * 1e3;
+var OPENAI_EPHEMERAL_BACKGROUND_RETENTION_MS = 10 * 60 * 1e3;
+function isOpenAIConversationHostInput(value) {
+  if (!isRecord(value) || value.kind !== "openai.responses") return false;
+  return typeof value.requestId === "string" && typeof value.responseId === "string" && typeof value.projectId === "string" && typeof value.model === "string" && Array.isArray(value.messages) && isRecord(value.settings);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/openai-responses-runner.ts
+async function main(options = {}) {
+  const writeProtocolLine = options.writeProtocolLine ?? isolateOpenAIRunnerStdout();
+  redirectConsoleToStderr();
+  const controller = createProcessAbortController();
+  return runOpenAIResponsesRunner({
+    abortSignal: controller.signal,
+    writeFrame: (frame) => writeProtocolLine(`${JSON.stringify(frame)}
+`)
+  });
+}
+async function runOpenAIResponsesRunner(dependencies = {}) {
+  disableAiSdkWarningLogs();
+  const writeFrame = dependencies.writeFrame ?? writeRunnerFrame;
+  let request;
+  let executionReport;
+  try {
+    request = parseOpenAIInternalRunnerRequest(
+      (dependencies.readInput ?? (() => readFileSync(0, "utf8")))()
+    );
+    const inspectProject = dependencies.inspectProject ?? inspectLocalWorkflowStructure;
+    const structure = inspectProject({ workflowDir: request.projectPath });
+    const conversation = structure.conversation;
+    if (structure.projectType !== "conversation" || conversation?.openai?.enabled !== true || typeof conversation.openai.outputItemId !== "string") {
+      throw new Error("The project does not expose an OpenAI Responses adapter.");
+    }
+    const outputItemId = conversation.openai.outputItemId;
+    writeFrame({ type: "ready", executionId: request.executionId });
+    const runWorkflow = dependencies.runWorkflow ?? runLocalWorkflowWithReport;
+    executionReport = await runWorkflow({
+      workflowDir: request.projectPath,
+      runId: request.executionId,
+      hostInput: request.hostInput,
+      abortSignal: dependencies.abortSignal,
+      nodeHooks: createRunnerNodeHooks(request.executionId, outputItemId, writeFrame)
+    });
+    const report = executionReport;
+    if (dependencies.abortSignal?.aborted) {
+      writeFrame({ type: "cancelled", executionId: request.executionId, report });
+      return 130;
+    }
+    if (report.status !== "success") {
+      writeFrame({
+        type: "failed",
+        executionId: request.executionId,
+        error: { message: readReportError(report) },
+        report
+      });
+      return 1;
+    }
+    const item = findOutputItem(report, outputItemId);
+    if (item === void 0 || typeof item.content !== "string") {
+      throw new Error(`OpenAI adapter output item "${outputItemId}" was not produced.`);
+    }
+    const metadata = isRecord2(item.metadata) ? item.metadata : {};
+    writeFrame({
+      type: "completed",
+      executionId: request.executionId,
+      outputText: item.content,
+      outputItemId,
+      usage: createOpenAIUsage(report),
+      report,
+      ...typeof metadata.finishReason === "string" ? { finishReason: metadata.finishReason } : {},
+      ...metadata.providerMetadata === void 0 ? {} : { providerMetadata: metadata.providerMetadata }
+    });
+    return 0;
+  } catch (error) {
+    const executionId = request?.executionId ?? "unknown";
+    if (dependencies.abortSignal?.aborted) {
+      writeFrame({
+        type: "cancelled",
+        executionId,
+        ...executionReport === void 0 ? {} : { report: executionReport }
+      });
+      return 130;
+    }
+    writeFrame({
+      type: "failed",
+      executionId,
+      error: { message: error instanceof Error ? error.message : "OpenAI runner failed." },
+      ...executionReport === void 0 ? {} : { report: executionReport }
+    });
+    return 1;
+  }
+}
+function parseOpenAIInternalRunnerRequest(source) {
+  const value = JSON.parse(source);
+  if (!isRecord2(value)) throw new Error("Runner request must be a JSON object.");
+  if (value.protocolVersion !== 1 || value.action !== "run") {
+    throw new Error("Unsupported OpenAI runner protocol version or action.");
+  }
+  if (typeof value.executionId !== "string" || value.executionId.trim() === "" || typeof value.projectPath !== "string" || value.projectPath.trim() === "" || !isOpenAIConversationHostInput(value.hostInput)) {
+    throw new Error("OpenAI runner request is invalid.");
+  }
+  return value;
+}
+function createRunnerNodeHooks(executionId, outputItemId, writeFrame) {
+  return {
+    onNodeChunk(event) {
+      if (!isOutputItemStreamChunk(event.chunk)) return;
+      if (event.chunk.type !== "output_item_delta" || event.chunk.itemId !== outputItemId) return;
+      if (typeof event.chunk.delta !== "string" || event.chunk.delta === "") return;
+      writeFrame({ type: "text-delta", executionId, delta: event.chunk.delta });
+    }
+  };
+}
+function createOpenAIUsage(report) {
+  const usage = report.tokenUsage?.run;
+  return {
+    input_tokens: usage?.inputTokens ?? 0,
+    input_tokens_details: { cached_tokens: usage?.cachedInputTokens ?? 0 },
+    output_tokens: usage?.outputTokens ?? 0,
+    output_tokens_details: { reasoning_tokens: usage?.reasoningTokens ?? 0 },
+    total_tokens: usage?.totalTokens ?? 0
+  };
+}
+function findOutputItem(report, outputItemId) {
+  for (const output of report.outputs) {
+    const item = output.output.items.find((candidate) => candidate.id === outputItemId);
+    if (item !== void 0) return item;
+  }
+  return void 0;
+}
+function readReportError(report) {
+  if (!report.result.ok) {
+    return readDeepestErrorMessage(report.result.error) ?? report.result.error.message;
+  }
+  const nodeError = report.nodes.find((node) => node.error !== void 0)?.error;
+  if (nodeError !== void 0) return readDeepestErrorMessage(nodeError) ?? nodeError.message;
+  return `Workflow execution ended with status ${report.status}.`;
+}
+function readDeepestErrorMessage(value) {
+  let current = value;
+  let message;
+  const seen = /* @__PURE__ */ new Set();
+  while (isRecord2(current) && !seen.has(current)) {
+    seen.add(current);
+    const candidate = typeof current.message === "string" ? current.message.trim() : "";
+    if (candidate !== "") message = candidate;
+    current = current.cause;
+  }
+  return message;
+}
+function writeRunnerFrame(frame) {
+  process.stdout.write(`${JSON.stringify(frame)}
+`);
+}
+function createProcessAbortController() {
+  const controller = new AbortController();
+  const abort = () => {
+    if (!controller.signal.aborted) controller.abort(new Error("OpenAI runner was cancelled."));
+  };
+  process.once("SIGINT", abort);
+  process.once("SIGTERM", abort);
+  return controller;
+}
+function redirectConsoleToStderr() {
+  const write = (...values) => {
+    process.stderr.write(`${values.map(formatDiagnosticValue).join(" ")}
+`);
+  };
+  console.log = write;
+  console.info = write;
+  console.debug = write;
+  console.warn = write;
+}
+function disableAiSdkWarningLogs() {
+  globalThis.AI_SDK_LOG_WARNINGS = false;
+}
+function formatDiagnosticValue(value) {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export {
+  main,
+  parseOpenAIInternalRunnerRequest,
+  runOpenAIResponsesRunner
+};

package/dist/openai-runner-stdio-ZQJG73I4.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import {
+  isolateOpenAIRunnerStdout
+} from "./chunk-OLNPMIEF.js";
+import "./chunk-NSPRIPOP.js";
+export {
+  isolateOpenAIRunnerStdout
+};