@smithers-orchestrator/agents 0.16.0

package/src/index.js

@@ -0,0 +1,39 @@
+// @smithers-type-exports-begin
+/** @typedef {import("./capability-registry/AgentCapabilityRegistry.ts").AgentCapabilityRegistry} AgentCapabilityRegistry */
+/** @typedef {import("./AgentLike.ts").AgentLike} AgentLike */
+/** @typedef {import("./capability-registry/AgentToolDescriptor.ts").AgentToolDescriptor} AgentToolDescriptor */
+/**
+ * @template [CALL_OPTIONS=never]
+ * @template [TOOLS=import("ai").ToolSet]
+ * @typedef {import("./AnthropicAgentOptions.ts").AnthropicAgentOptions<CALL_OPTIONS, TOOLS>} AnthropicAgentOptions
+ */
+/**
+ * @template [CALL_OPTIONS=never]
+ * @template [TOOLS=import("ai").ToolSet]
+ * @typedef {import("./OpenAIAgentOptions.ts").OpenAIAgentOptions<CALL_OPTIONS, TOOLS>} OpenAIAgentOptions
+ */
+/** @typedef {import("./PiAgentOptions.ts").PiAgentOptions} PiAgentOptions */
+/** @typedef {import("./BaseCliAgent/PiExtensionUiRequest.ts").PiExtensionUiRequest} PiExtensionUiRequest */
+/** @typedef {import("./BaseCliAgent/PiExtensionUiResponse.ts").PiExtensionUiResponse} PiExtensionUiResponse */
+/** @typedef {import("./agent-contract/SmithersAgentContract.ts").SmithersAgentContract} SmithersAgentContract */
+/** @typedef {import("./agent-contract/SmithersAgentContractTool.ts").SmithersAgentContractTool} SmithersAgentContractTool */
+/** @typedef {import("./agent-contract/SmithersAgentToolCategory.ts").SmithersAgentToolCategory} SmithersAgentToolCategory */
+/** @typedef {import("./agent-contract/SmithersListedTool.ts").SmithersListedTool} SmithersListedTool */
+/** @typedef {import("./agent-contract/SmithersToolSurface.ts").SmithersToolSurface} SmithersToolSurface */
+// @smithers-type-exports-end
+
+export { BaseCliAgent } from "./BaseCliAgent/index.js";
+export { hashCapabilityRegistry } from "./capability-registry/index.js";
+export { AnthropicAgent } from "./AnthropicAgent.js";
+export { OpenAIAgent } from "./OpenAIAgent.js";
+export { AmpAgent } from "./AmpAgent.js";
+export { ClaudeCodeAgent } from "./ClaudeCodeAgent.js";
+export { CodexAgent } from "./CodexAgent.js";
+export { GeminiAgent } from "./GeminiAgent.js";
+export { PiAgent } from "./PiAgent.js";
+export { KimiAgent } from "./KimiAgent.js";
+export { ForgeAgent } from "./ForgeAgent.js";
+export { createSmithersAgentContract } from "./agent-contract/createSmithersAgentContract.js";
+export { renderSmithersAgentPromptGuidance } from "./agent-contract/renderSmithersAgentPromptGuidance.js";
+export { zodToOpenAISchema } from "./zodToOpenAISchema.js";
+export { sanitizeForOpenAI } from "./sanitizeForOpenAI.js";

package/src/resolveSdkModel.js

@@ -0,0 +1,9 @@
+/**
+ * @template MODEL
+ * @param {string | MODEL} value
+ * @param {(modelId: string) => MODEL} create
+ * @returns {MODEL}
+ */
+export function resolveSdkModel(value, create) {
+    return typeof value === "string" ? create(value) : value;
+}

package/src/sanitizeForOpenAI.js

@@ -0,0 +1,47 @@
+/**
+ * Sanitize a JSON Schema for OpenAI's structured-output API.
+ *
+ * OpenAI's `response_format` imposes constraints beyond standard JSON Schema:
+ *
+ * 1. Every object node **must** include `"type": "object"`.
+ * 2. `additionalProperties` must be a boolean or a valid sub-schema with a
+ *    `type` key -- bare `{}` is rejected.
+ * 3. `additionalProperties: true` is accepted but tells the model it can
+ *    return extra keys -- set to `false` if you want strict conformance.
+ *
+ * Zod v4's `toJSONSchema()` can violate (1) when `z.looseObject()` is used:
+ * it emits `{ additionalProperties: true }` without `"type": "object"`.
+ *
+ * This function fixes these issues in-place so any agent (Codex, future
+ * OpenAI-backed agents, etc.) can safely use a JSON Schema for OpenAI.
+ */
+export function sanitizeForOpenAI(node) {
+    if (node == null || typeof node !== "object")
+        return;
+    const obj = node;
+    // Rule 1 & 2: If a node has `additionalProperties`, it must also
+    // have `"type": "object"`.  Zod's toJSONSchema omits `type` on
+    // passthrough objects, which OpenAI rejects.
+    if ("additionalProperties" in obj && !("type" in obj)) {
+        obj.type = "object";
+    }
+    // Rule 2b: If `additionalProperties` is an empty object `{}`,
+    // OpenAI rejects it because it lacks a `type` key.  Coerce to `true`
+    // which is semantically equivalent and accepted by OpenAI.
+    if (typeof obj.additionalProperties === "object" &&
+        obj.additionalProperties !== null &&
+        !Array.isArray(obj.additionalProperties) &&
+        Object.keys(obj.additionalProperties).length === 0) {
+        obj.additionalProperties = true;
+    }
+    // Recurse into all sub-schemas
+    for (const value of Object.values(obj)) {
+        if (Array.isArray(value)) {
+            for (const item of value)
+                sanitizeForOpenAI(item);
+        }
+        else if (typeof value === "object" && value !== null) {
+            sanitizeForOpenAI(value);
+        }
+    }
+}

package/src/streamResultToGenerateResult.js

@@ -0,0 +1,70 @@
+
+/** @typedef {import("ai").GenerateTextResult} GenerateTextResult */
+/** @typedef {import("ai").StreamTextResult} StreamTextResult */
+/**
+ * @template TOOLS, OUTPUT
+ * @param {StreamTextResult<TOOLS, any>} stream
+ * @param {(text: string) => void} [onStdout]
+ * @returns {Promise<GenerateTextResult<TOOLS, any>>}
+ */
+export async function streamResultToGenerateResult(stream, onStdout) {
+    if (onStdout) {
+        for await (const part of stream.fullStream) {
+            if (part.type === "text-delta" && part.text) {
+                onStdout(part.text);
+            }
+        }
+    }
+    else {
+        await stream.consumeStream();
+    }
+    const [content, text, reasoning, reasoningText, files, sources, toolCalls, staticToolCalls, dynamicToolCalls, toolResults, staticToolResults, dynamicToolResults, finishReason, rawFinishReason, usage, totalUsage, warnings, steps, request, response, providerMetadata, output,] = await Promise.all([
+        stream.content,
+        stream.text,
+        stream.reasoning,
+        stream.reasoningText,
+        stream.files,
+        stream.sources,
+        stream.toolCalls,
+        stream.staticToolCalls,
+        stream.dynamicToolCalls,
+        stream.toolResults,
+        stream.staticToolResults,
+        stream.dynamicToolResults,
+        stream.finishReason,
+        stream.rawFinishReason,
+        stream.usage,
+        stream.totalUsage,
+        stream.warnings,
+        stream.steps,
+        stream.request,
+        stream.response,
+        stream.providerMetadata,
+        stream.output,
+    ]);
+    return {
+        content,
+        text,
+        reasoning,
+        reasoningText,
+        files,
+        sources,
+        toolCalls,
+        staticToolCalls,
+        dynamicToolCalls,
+        toolResults,
+        staticToolResults,
+        dynamicToolResults,
+        finishReason,
+        rawFinishReason,
+        usage,
+        totalUsage,
+        warnings,
+        request,
+        response,
+        providerMetadata,
+        steps,
+        experimental_output: output,
+        output,
+    };
+}

package/src/zodToOpenAISchema.js

@@ -0,0 +1,16 @@
+import { sanitizeForOpenAI } from "./sanitizeForOpenAI.js";
+/**
+ * Convert a Zod schema to an OpenAI-safe JSON Schema object.
+ *
+ * Usage:
+ * ```ts
+ * import { zodToOpenAISchema } from "./zodToOpenAISchema";
+ * const jsonSchema = zodToOpenAISchema(myZodSchema);
+ * ```
+ */
+export async function zodToOpenAISchema(zodSchema) {
+    const { z } = await import("zod");
+    const jsonSchema = z.toJSONSchema(zodSchema);
+    sanitizeForOpenAI(jsonSchema);
+    return jsonSchema;
+}