@theoremjs/agents 0.3.4-next.480.ge8c8d47 → 0.3.4-next.484.g20d8b9d

package/esm/src/providers/openrouter/decisions-protocol.d.ts

@@ -1,4 +1,6 @@
 import { type Protocol } from '../../kernel/protocols/mod.js';
-import { type SystemOneOptions } from '../system-one/protocol.js';
-/** OpenRouter's decision API: System One's questions and answers, at OpenRouter's own endpoint. */
-export declare const openRouterDecisions: Protocol<SystemOneOptions>;
+/**
+ * OpenRouter's decision API: questions about a state, answered in one call. It takes no options:
+ * images and box questions need no opt-in, and a request with an image runs in long context.
+ */
+export declare const openRouterDecisions: Protocol<Record<string, never>>;

package/esm/src/providers/openrouter/decisions-protocol.js

@@ -1,9 +1,57 @@
-import { extendProtocol } from '../../kernel/protocols/mod.js';
-import { systemOne } from '../system-one/protocol.js';
-/** OpenRouter's decision API: System One's questions and answers, at OpenRouter's own endpoint. */
-export const openRouterDecisions = extendProtocol(systemOne, {
+import { z } from 'zod';
+import { jsonObjectSchema } from '../../kernel/json.js';
+import { defineProtocol } from '../../kernel/protocols/mod.js';
+import { decisionAnswered } from '../system-one/protocol.js';
+/**
+ * OpenRouter's decision API: questions about a state, answered in one call. It takes no options:
+ * images and box questions need no opt-in, and a request with an image runs in long context.
+ */
+export const openRouterDecisions = defineProtocol({
     id: 'openRouterDecisions',
     name: 'OpenRouter Decisions',
     description: "OpenRouter's decision API: questions about a state, answered in one call.", // labels-exempt: builder field description, read by the studio and docs
     endpoints: { decision: '/alpha/decisions' },
+    options: z.strictObject({}),
+    create(context) {
+        return {
+            decide(request) {
+                const assets = request.assets ?? {};
+                const body = jsonObjectSchema.parse({
+                    model: context.apiId,
+                    state: withImages(request.state, assets),
+                    questions: Object.fromEntries(Object.entries(request.questions).map(([id, question]) => [
+                        id,
+                        {
+                            ...question,
+                            instructions: withImages(question.instructions, assets),
+                            ...('criteria' in question && question.criteria !== undefined
+                                ? { criteria: withImages(question.criteria, assets) }
+                                : {}),
+                        },
+                    ])),
+                });
+                return decisionAnswered('openRouterDecisions', context.send(body, { stream: false }));
+            },
+        };
+    },
 });
+/**
+ * Each reference becomes the reference followed by its image, where the reference was.
+ * why: OpenRouter ignores an `assets` map; it reads image parts in place.
+ */
+function withImages(value, assets) {
+    if (typeof value === 'string') {
+        const asset = assets[value];
+        return asset
+            ? [
+                value,
+                { type: 'image_url', image_url: { url: `data:${asset.mimeType};base64,${asset.data}` } },
+            ]
+            : value;
+    }
+    if (Array.isArray(value))
+        return value.map((item) => withImages(item, assets));
+    if (value !== null && typeof value === 'object')
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, withImages(item, assets)]));
+    return value;
+}

package/esm/src/providers/system-one/protocol.d.ts

@@ -1,4 +1,6 @@
+import { type JsonObject } from '../../kernel/json.js';
 import { type Protocol } from '../../kernel/protocols/mod.js';
+import type { DecisionResult } from '../../kernel/types.js';
 /** What a System One binding may set. Both are TypeSafe's opt-in "danger zone" headers. */
 export interface SystemOneOptions {
     images?: boolean;
@@ -6,3 +8,5 @@ export interface SystemOneOptions {
 }
 /** TypeSafe's decision API: questions about a state, answered in one call. */
 export declare const systemOne: Protocol<SystemOneOptions>;
+/** The first decision reply, read into the kernel's result. Shared by every decision API that answers as System One does. */
+export declare function decisionAnswered(protocol: string, rows: AsyncIterable<JsonObject>): Promise<DecisionResult>;

package/esm/src/providers/system-one/protocol.js

@@ -56,34 +56,35 @@ export const systemOne = defineProtocol({
                         ? { assets: assetsOnWire(request.assets) }
                         : {}),
                 });
-                for await (const row of context.send(body, { stream: false, headers })) {
-                    const parsed = reply.safeParse(row);
-                    if (!parsed.success)
-                        throw new TheoremError('bad_response', labelText('protocol.reply_shape', {
-                            protocol: 'systemOne',
-                            issues: z.prettifyError(parsed.error),
-                        }));
-                    const { model, answers, usage } = parsed.data;
-                    // invariant: The kernel validates every answer against its question before exposing it.
-                    return {
-                        model,
-                        answers: answers,
-                        ...(usage
-                            ? {
-                                usage: {
-                                    inputTokens: usage.input_tokens,
-                                    outputTokens: usage.output_tokens,
-                                    ...(usage.cost === undefined ? {} : { costUsd: usage.cost }),
-                                },
-                            }
-                            : {}),
-                    };
-                }
-                throw new TheoremError('bad_response', labelText('provider.decision_failed'));
+                return await decisionAnswered('systemOne', context.send(body, { stream: false, headers }));
             },
         };
     },
 });
+/** The first decision reply, read into the kernel's result. Shared by every decision API that answers as System One does. */
+export async function decisionAnswered(protocol, rows) {
+    for await (const row of rows) {
+        const parsed = reply.safeParse(row);
+        if (!parsed.success)
+            throw new TheoremError('bad_response', labelText('protocol.reply_shape', { protocol, issues: z.prettifyError(parsed.error) }));
+        const { model, answers, usage } = parsed.data;
+        // invariant: The kernel validates every answer against its question before exposing it.
+        return {
+            model,
+            answers: answers,
+            ...(usage
+                ? {
+                    usage: {
+                        inputTokens: usage.input_tokens,
+                        outputTokens: usage.output_tokens,
+                        ...(usage.cost === undefined ? {} : { costUsd: usage.cost }),
+                    },
+                }
+                : {}),
+        };
+    }
+    throw new TheoremError('bad_response', labelText('provider.decision_failed'));
+}
 const FORMATS = { 'image/png': 'png', 'image/jpeg': 'jpeg' };
 function assetsOnWire(assets) {
     return Object.fromEntries(Object.entries(assets).map(([reference, { mimeType, data }]) => [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@theoremjs/agents",
-  "version": "0.3.4-next.480.ge8c8d47",
+  "version": "0.3.4-next.484.g20d8b9d",
   "description": "A flat TypeScript agent kernel for typed profiles, deterministic turn execution, registered tools, provider adapters, guardrails, and host-injected traces.",
   "keywords": [
     "agent",