@oh-my-ai-sdk/omakase 0.1.1 → 0.1.2

package/README.md

@@ -12,15 +12,16 @@ configured URI sources. No model-facing registry-management tools.
 ## CLI setup
 
 Requires Node.js 22.13 or newer. The host itself needs no model key; your calling
-Claude/Codex session supplies its own model. Registered child agents additionally
-need Bun, their bootstrap prerequisites, and their own configured credentials
-(see below). Configuration stays outside harness MCP registration.
+Claude/Codex session supplies its own model. Registered child agents and decision
+tools use their own configured credentials. Child agents additionally need Bun
+and their bootstrap prerequisites (see below). Configuration stays outside
+harness MCP registration.
 
-For a local beta candidate, install its packed `.tgz` with `bun add /absolute/path/to/archive.tgz`
+For a local candidate, install its packed `.tgz` with `bun add /absolute/path/to/archive.tgz`
 and configure your MCP client with the absolute path to that installation's
-`node_modules/.bin/omakase`. The registry commands below require the `beta`
-dist-tag to have been published; building or installing a local candidate does
-not publish it.
+`node_modules/.bin/omakase`. The registry commands below install the published
+`latest` release on the `0.1.x` line. Building or installing a local candidate
+does not publish it.
 
 Create `~/.config/omakase/host.config.mjs` (or
 `$XDG_CONFIG_HOME/omakase/host.config.mjs`):
@@ -321,6 +322,88 @@ The private OMP adapter is not bundled: OMP **as a child backend** requires its
 separately installed/built adapter; using an MCP-capable harness as the caller
 does not require that child adapter.
 
+## Decision controller in ordinary or durable cells
+
+`createDecisionTool({ model, configurationId })` returns an ordinary AI SDK tool.
+Register it as `tools.decision` in a custom host, or set the optional `decision`
+configuration on `createSkillsHost` to add it alongside `tools.read`. The existing
+MCP server still exposes one `cell` tool; no separate decision server is needed.
+
+Example `host.config.mjs` (install the provider beside this config, not inside
+Omakase):
+
+```js
+import { createTypeSafeAi } from '@ai-sdk/typesafe-ai';
+
+export default async ({ createSkillsHost }) => createSkillsHost({
+  collections: [],
+  cwd: '/absolute/path/to/workspace',
+  decision: {
+    model: createTypeSafeAi().decisionModel('jev-1.13.0'),
+    configurationId: 'review-controller-v1',
+  },
+});
+```
+
+This example uses `TYPESAFE_AI_API_KEY` and the tested
+`@ai-sdk/typesafe-ai@3.0.13` adapter with Omakase's pinned `ai@7.0.128`.
+The experimental decision protocol can change in patch releases: adapter
+`3.0.17` expects a newer state representation and is not compatible with this
+core version. No provider is installed, selected, or silently substituted by
+Omakase. Other SDK decision-model instances may be supplied, but their provider
+compatibility must be verified; this release does not include a Clef adapter.
+
+Native custom hosts import `createDecisionTool` from `@oh-my-ai-sdk/omakase` and
+use `await host.register('tools', { decision: createDecisionTool(options) })`.
+Include other `tools` leaves in that same registration: namespaces cannot be
+registered twice. The CLI also supplies `createDecisionTool` to its host factory.
+
+Submit this body through the existing `cell` API:
+
+```ts
+const { answers } = await tools.decision({
+  state: { reviews: ["No blocking defects"], tests: "passed" },
+  questions: {
+    blocked: { type: "boolean", instructions: "Is there a blocking defect?" },
+    next: {
+      type: "choice",
+      instructions: "Choose the next action.",
+      criteria: { fix: "Repair a defect", finish: "Verified completion" },
+    },
+    quality: {
+      type: "score",
+      instructions: "Rate completeness.",
+      criteria: ["Incomplete", "Partly complete", "Complete"],
+    },
+  },
+});
+const { blocked, next, quality } = answers;
+if (!blocked || !next || !quality ||
+    blocked.type !== "boolean" || next.type !== "choice" || quality.type !== "score")
+  throw new Error("Unexpected decision answer types");
+return { blocked: blocked.probability, next: next.choice, quality: quality.score };
+```
+
+- State and instructions accept a JSON string, object or array. Question names
+  identify answers. Criteria descriptions can additionally be `null`.
+- `boolean` returns P(true), not a Boolean flag. `choice` returns an option name.
+  `score` returns a fractional position from zero through the last rubric index.
+  Choice/score distributions are optional; calibration is not portable across
+  providers. The result contains `{ answers, modelId }`, not SDK transport data.
+- JavaScript owns branching. A judgment never grants tool permissions or bypasses
+  native approval. Malformed answers and provider errors fail the tool call;
+  no fallback judgment or automatic inference retry is supplied.
+- Ordinary cells execute directly. Durable cells record each decision invocation;
+  all questions in one call share that checkpoint. Separate calls can progress
+  independently. Recorded answers are reused; an interrupted inference without a
+  committed receipt fails `OUTCOME_UNKNOWN` rather than silently re-inferencing.
+- The configured provider/model and `configurationId` contribute to durable
+  catalog identity via `metadata.omakase.executionIdentity`. Change the revision
+  whenever endpoint, adapter or hidden settings change, and keep model instances
+  immutable. Pending runs reject configuration drift with `RECOVERY_BLOCKED`;
+  retain the admitted configuration to recover them. Do not use secrets in this
+  revision or a moving model alias when reproducibility matters.
+
 ## Skill reads through Code Mode
 
 Call `cell({})` to inspect the current full leaf catalog. Submit the following

package/dist/agent-runtime/manifest.json

@@ -1,5 +1,5 @@
 {
-  "generatedAt": "2026-10-11T13:32:12.517Z",
+  "generatedAt": "2026-10-11T16:56:28.358Z",
   "entry": "worker.mjs",
   "runtime": "bun >=1.3.14 (launched per run by the host; stdin/stdout JSON wire)",
   "adapters": {

package/dist/agent-runtime/versions.json

@@ -1,8 +1,8 @@
 {
-  "generatedAt": "2026-10-11T13:32:12.517Z",
+  "generatedAt": "2026-10-11T16:56:28.358Z",
   "source": "resolved package manifests walked from esbuild metafile inputs (authoritative, not pin literals)",
   "packages": {
-    "@oh-my-ai-sdk/omakase": "0.1.1",
+    "@oh-my-ai-sdk/omakase": "0.1.2",
     "@ai-sdk/provider": "4.0.7",
     "eventsource-parser": "3.1.1",
     "@workflow/serde": "4.1.0",

package/dist/cell-declarations.d.ts

@@ -9,7 +9,7 @@ export type CellGuestContract = Readonly<{
     declarations: string;
     /** Sorted tool names of the snapshot, frozen with the fingerprint. */
     names: readonly string[];
-    /** Stable digest of the exact admitted catalog (names and schemas). */
+    /** Stable digest of the admitted catalog, including declared execution identities. */
     fingerprint: string;
 }>;
 /** Project one frozen host snapshot into the guest TypeScript contract. */

package/dist/cell-declarations.js

@@ -1,6 +1,7 @@
 import { createHash } from 'node:crypto';
 import { asSchema } from 'ai';
 import { isRecord } from './type-guard.js';
+import { toolExecutionIdentity } from './execution-policy.js';
 /**
  * Ambient TypeScript contract for one exact tool catalog snapshot plus the
  * guest bindings both cell engines really provide. The semantic preflight and
@@ -63,7 +64,7 @@ export async function projectCellGuestContract(tools) {
         const leaf = tools[name];
         const input = await disclosedSchema(leaf.inputSchema);
         const output = leaf.outputSchema === undefined ? undefined : await disclosedSchema(leaf.outputSchema);
-        projected.push({ name, input, output, signature: `(input: ${schemaToType(input)}) => Promise<${output === undefined ? 'unknown' : schemaToType(output)}>` });
+        projected.push({ name, input, output, executionIdentity: toolExecutionIdentity(leaf), signature: `(input: ${schemaToType(input)}) => Promise<${output === undefined ? 'unknown' : schemaToType(output)}>` });
     }
     const canonicalNames = new Set(projected.map(entry => entry.name));
     const fields = projected.flatMap(entry => {
@@ -96,7 +97,11 @@ export async function projectCellGuestContract(tools) {
         '}>;',
     ].join('\n'));
     const declarations = [CONSOLE_DECLARATION, PARALLEL_DECLARATIONS, ...toolEntries, ...namespaceEntries].join('\n');
-    const fingerprint = createHash('sha256').update(JSON.stringify(projected.map(entry => [entry.name, entry.input, entry.output ?? null]))).digest('hex');
+    // Preserve existing fingerprints when no implementation identity was declared.
+    const fingerprint = createHash('sha256').update(JSON.stringify(projected.map(entry => [
+        entry.name, entry.input, entry.output ?? null,
+        ...(entry.executionIdentity === undefined ? [] : [entry.executionIdentity]),
+    ]))).digest('hex');
     return Object.freeze({ declarations, names: Object.freeze(projected.map(entry => entry.name)), fingerprint });
 }
 // JSON Schema to TypeScript projection adapted from packages/bun-workbench

package/dist/cli.js

@@ -11,6 +11,7 @@ import { createToolHost } from './host.js';
 import { mountMcpConfigFile } from './mcp-config.js';
 import { createCellFrontend } from './frontend.js';
 import { createLazyDurableCellExecutor } from './cell.js';
+import { createDecisionTool } from './decision.js';
 let host;
 let server;
 let durable;
@@ -107,7 +108,7 @@ async function main() {
             throw new Error('Config must export a default async host factory');
         const { createSkillsHost } = await import('./skills-host.js');
         const { createAgentHost, mountAgents } = await import('./agents.js');
-        host = await config.default(Object.freeze({ ...context, createSkillsHost, createAgentHost, mountAgents }));
+        host = await config.default(Object.freeze({ ...context, createSkillsHost, createAgentHost, mountAgents, createDecisionTool }));
     }
     if (interrupted) {
         stopping = undefined;

package/dist/decision.d.ts

@@ -0,0 +1,28 @@
+import { type Experimental_DecisionAnswer, type Experimental_DecisionQuestion, type Experimental_DecisionModel, type JSONValue, type Tool } from 'ai';
+/** Model and revision are operator authority; guests only supply state and questions. */
+export type DecisionToolOptions = {
+    /** Decision model instance bound at construction. Model id strings are rejected:
+     * they would silently resolve through the ambient default provider or gateway. */
+    readonly model: Exclude<Experimental_DecisionModel, string>;
+    /** Operator revision token distinguishing endpoint or settings revisions of the
+     * same provider and model. Never a credential; never guest-supplied. */
+    readonly configurationId: string;
+};
+/** Guest-visible input: one shared state plus named questions of any supported type. */
+export type DecisionInput = {
+    state: DecisionState;
+    questions: Record<string, Experimental_DecisionQuestion>;
+};
+/** JSON-only result: answers keyed by question name plus the answering model id.
+ * Never the full SDK decision result, whose response carries a Date. */
+export type DecisionOutput = {
+    answers: Record<string, Experimental_DecisionAnswer<Experimental_DecisionQuestion>>;
+    modelId: string;
+};
+/** SDK decision input contract: shared state must be a JSON string, object, or array. */
+type DecisionState = string | Readonly<Record<string, JSONValue>> | readonly JSONValue[];
+/** Decision tool over the SDK decide operation. The model instance, invocation
+ * options (maxRetries 0, caller-supplied abort signal), and identity hash are
+ * pinned at construction; guest input can never select or reconfigure them. */
+export declare function createDecisionTool(options: DecisionToolOptions): Tool<DecisionInput, DecisionOutput>;
+export {};

package/dist/decision.js

@@ -0,0 +1,193 @@
+import { createHash } from 'node:crypto';
+import { experimental_decide, jsonSchema, tool, } from 'ai';
+import { assertJson, prepareSchema } from './schema.js';
+import { isRecord } from './type-guard.js';
+/** Bump whenever decision tool invocation semantics change; hashed into execution identity. */
+const IDENTITY_VERSION = 'omakase-decision-tool/v1';
+const instructionsSchema = {
+    description: 'What to judge: a JSON string, object, or array.',
+    anyOf: [{ type: 'string' }, { type: 'object' }, { type: 'array' }],
+};
+const descriptionSchema = {
+    description: 'Option or level description: null or a JSON string, object, or array.',
+    anyOf: [{ type: 'string' }, { type: 'object' }, { type: 'array' }, { type: 'null' }],
+};
+const questionSchema = {
+    anyOf: [
+        {
+            type: 'object',
+            description: 'boolean question: answered with P(true).',
+            properties: {
+                type: { const: 'boolean' },
+                instructions: instructionsSchema,
+                criteria: {
+                    type: 'object',
+                    description: 'Optional outcome descriptions; only the keys "true" and "false" are allowed.',
+                    properties: { true: descriptionSchema, false: descriptionSchema },
+                    additionalProperties: false,
+                },
+            },
+            required: ['type', 'instructions'],
+            additionalProperties: false,
+        },
+        {
+            type: 'object',
+            description: 'choice question: answered with exactly one named option.',
+            properties: {
+                type: { const: 'choice' },
+                instructions: instructionsSchema,
+                criteria: {
+                    type: 'object',
+                    description: 'Nonempty map of option name to description; the answer names one option.',
+                    minProperties: 1,
+                    additionalProperties: descriptionSchema,
+                },
+            },
+            required: ['type', 'instructions', 'criteria'],
+            additionalProperties: false,
+        },
+        {
+            type: 'object',
+            description: 'score question: answered with a position on an ordered rubric.',
+            properties: {
+                type: { const: 'score' },
+                instructions: instructionsSchema,
+                criteria: {
+                    type: 'array',
+                    description: 'Ordered rubric levels indexed from zero; at least two levels.',
+                    minItems: 2,
+                    items: descriptionSchema,
+                },
+            },
+            required: ['type', 'instructions', 'criteria'],
+            additionalProperties: false,
+        },
+    ],
+};
+const decisionInputContract = {
+    type: 'object',
+    description: 'Ask the operator-configured decision model questions about one shared state. Model, provider, and endpoint selection is host authority and never accepted here.',
+    properties: {
+        state: {
+            description: 'The single shared state every question is judged against: a JSON string, object, or array.',
+            anyOf: [{ type: 'string' }, { type: 'object' }, { type: 'array' }],
+        },
+        questions: {
+            type: 'object',
+            description: 'Nonempty map of question name to question; exactly one typed answer is returned per name.',
+            minProperties: 1,
+            additionalProperties: questionSchema,
+        },
+    },
+    required: ['state', 'questions'],
+    additionalProperties: false,
+};
+const answerSchema = {
+    description: 'One typed answer; the type field narrows the payload.',
+    anyOf: [
+        {
+            type: 'object',
+            description: 'Boolean answer: probability is P(true).',
+            properties: {
+                type: { const: 'boolean' },
+                probability: { type: 'number', minimum: 0, maximum: 1 },
+            },
+            required: ['type', 'probability'],
+        },
+        {
+            type: 'object',
+            description: 'Choice answer: the selected option name, plus an optional distribution over the options.',
+            properties: {
+                type: { const: 'choice' },
+                choice: { type: 'string' },
+                probabilities: { type: 'object', additionalProperties: { type: 'number', minimum: 0, maximum: 1 } },
+            },
+            required: ['type', 'choice'],
+        },
+        {
+            type: 'object',
+            description: 'Score answer: the rubric position, plus an optional distribution over level indexes.',
+            properties: {
+                type: { const: 'score' },
+                score: { type: 'number', minimum: 0 },
+                probabilities: { type: 'object', additionalProperties: { type: 'number', minimum: 0, maximum: 1 } },
+            },
+            required: ['type', 'score'],
+        },
+    ],
+};
+const decisionOutputContract = {
+    type: 'object',
+    description: 'Answers keyed by question name plus the answering model id. JSON only.',
+    properties: {
+        answers: {
+            type: 'object',
+            description: 'Exactly one answer per requested question name.',
+            minProperties: 1,
+            additionalProperties: answerSchema,
+        },
+        modelId: { type: 'string', minLength: 1, description: 'The decision model that produced the answers.' },
+    },
+    required: ['answers', 'modelId'],
+    additionalProperties: false,
+};
+function deepFreeze(value) {
+    for (const child of Object.values(value))
+        if (child && typeof child === 'object')
+            deepFreeze(child);
+    Object.freeze(value);
+}
+deepFreeze(decisionInputContract);
+deepFreeze(decisionOutputContract);
+const decisionInputSchema = jsonSchema(decisionInputContract);
+const decisionOutputSchema = jsonSchema(decisionOutputContract);
+// The host and direct native invocation share the same boundary validator.
+// Prepare lazily once; do not duplicate the SDK's question/answer semantics.
+let preparedInput;
+/** Projects SDK-validated answers onto the JSON output contract: optional
+ * probabilities fields are emitted only when the provider defined them, so
+ * answers carrying explicit undefined values stay JSON-valid. Required fields
+ * pass through verbatim; the SDK has already validated their semantics. */
+function projectDecisionAnswers(answers) {
+    return Object.fromEntries(Object.entries(answers).map(([id, answer]) => {
+        if (answer.type === 'choice')
+            return [id, { type: 'choice', choice: answer.choice, ...(answer.probabilities === undefined ? {} : { probabilities: answer.probabilities }) }];
+        if (answer.type === 'score')
+            return [id, { type: 'score', score: answer.score, ...(answer.probabilities === undefined ? {} : { probabilities: answer.probabilities }) }];
+        return [id, { type: 'boolean', probability: answer.probability }];
+    }));
+}
+/** Decision tool over the SDK decide operation. The model instance, invocation
+ * options (maxRetries 0, caller-supplied abort signal), and identity hash are
+ * pinned at construction; guest input can never select or reconfigure them. */
+export function createDecisionTool(options) {
+    if (!isRecord(options))
+        throw new Error('Decision tool options must be an object');
+    if (typeof options.configurationId !== 'string' || options.configurationId.trim() === '')
+        throw new Error('Decision tool configurationId must be a nonblank string');
+    const model = options.model;
+    if (!model || typeof model !== 'object' || typeof model.provider !== 'string' || !model.provider.trim() || typeof model.modelId !== 'string' || !model.modelId.trim())
+        throw new Error('Decision tool requires a configured decision model instance');
+    const provider = model.provider;
+    const modelId = model.modelId;
+    const executionIdentity = createHash('sha256').update(JSON.stringify([IDENTITY_VERSION, provider, modelId, options.configurationId])).digest('hex');
+    const metadata = { omakase: { replay: 'safe', executionIdentity } };
+    Object.freeze(metadata.omakase);
+    Object.freeze(metadata);
+    return tool({
+        description: 'Answer typed judgment questions about one shared state with the operator-configured decision model. Ask several named questions in a single call: boolean questions return P(true), choice questions select exactly one named option, score questions place the state on an ordered rubric indexed from zero. The decision model, provider, and endpoint are fixed by the host operator and cannot be selected or reconfigured through input. Returns { answers, modelId } with exactly one typed answer per question name.',
+        inputSchema: decisionInputSchema,
+        outputSchema: decisionOutputSchema,
+        metadata,
+        execute: async (input, execution) => {
+            if (model.provider !== provider || model.modelId !== modelId)
+                throw new Error('Decision model provider or modelId changed after decision tool construction; recreate the tool to bind the new identity');
+            const prepared = await (preparedInput ??= prepareSchema(decisionInputSchema));
+            await prepared.validate(input);
+            const decision = await experimental_decide({ model, state: input.state, questions: input.questions, maxRetries: 0, abortSignal: execution.abortSignal });
+            const answers = projectDecisionAnswers(decision.answers);
+            assertJson(answers);
+            return { answers, modelId: decision.response.modelId };
+        },
+    });
+}

package/dist/durable-worker/versions.json

@@ -1,5 +1,5 @@
 {
-  "generatedAt": "2026-10-11T13:32:07.846Z",
+  "generatedAt": "2026-10-11T16:56:22.262Z",
   "source": "resolved package manifests from the isolated scratch graph (authoritative, not pin literals)",
   "packages": {
     "@workflow/utils": "4.1.4",

package/dist/execution-policy.d.ts

@@ -5,3 +5,7 @@ export declare function toolReplayPolicy(tool: {
 }): ToolReplayPolicy | undefined;
 /** Unknown executors fail closed for an explicitly unsafe implementation. */
 export declare function assertToolReplayPolicy(policy: ToolReplayPolicy | undefined, replays: boolean | undefined, name: string): void;
+/** Optional trusted configuration revision, included in durable admission. */
+export declare function toolExecutionIdentity(tool: {
+    metadata?: unknown;
+}): string | undefined;

package/dist/execution-policy.js

@@ -19,3 +19,20 @@ export function assertToolReplayPolicy(policy, replays, name) {
     if (policy === 'unsafe' && replays !== false)
         throw new Error(`Replay-unsafe tool cannot use a replaying or unspecified executor: ${name}`);
 }
+/** Optional trusted configuration revision, included in durable admission. */
+export function toolExecutionIdentity(tool) {
+    const metadata = tool.metadata;
+    if (!metadata || typeof metadata !== 'object')
+        return undefined;
+    const omakase = metadata.omakase;
+    if (omakase === undefined)
+        return undefined;
+    if (!omakase || typeof omakase !== 'object' || Array.isArray(omakase))
+        throw new Error('Invalid omakase execution metadata');
+    const identity = omakase.executionIdentity;
+    if (identity === undefined)
+        return undefined;
+    if (typeof identity !== 'string' || !identity.trim())
+        throw new Error('Tool execution identity must be a nonempty string');
+    return identity;
+}

package/dist/index.d.ts

@@ -11,3 +11,4 @@ export { createToolHostFrontend, createCellFrontend, HOST_FRONTEND_PREAMBLE, CEL
 export { createSkillLibrary, mountSkills, type SkillLibrary, type SkillEntry, type SkillRead } from './skills.js';
 export { createReadTool, createMcpReadResolver, mcpResourceAddress, type ReadResult, type ReadResolver, type ReadOptions } from './read.js';
 export { toolReplayPolicy, assertToolReplayPolicy, type ToolReplayPolicy } from './execution-policy.js';
+export { createDecisionTool, type DecisionToolOptions, type DecisionInput, type DecisionOutput } from './decision.js';

package/dist/index.js

@@ -9,3 +9,4 @@ export { createToolHostFrontend, createCellFrontend, HOST_FRONTEND_PREAMBLE, CEL
 export { createSkillLibrary, mountSkills } from './skills.js';
 export { createReadTool, createMcpReadResolver, mcpResourceAddress } from './read.js';
 export { toolReplayPolicy, assertToolReplayPolicy } from './execution-policy.js';
+export { createDecisionTool } from './decision.js';

package/dist/skills-host.d.ts

@@ -1,4 +1,5 @@
 import { type SkillCollection, type SkillsPeer } from './skills-server.js';
+import { type DecisionToolOptions } from './decision.js';
 /** Ready-to-run local host. The skills service owns collections and discovery;
  * the host imports its single list tool through the ordinary MCP adapter.
  */
@@ -6,4 +7,6 @@ export declare function createSkillsHost(options: {
     collections: readonly SkillCollection[];
     peers?: readonly SkillsPeer[];
     cwd?: string;
+    /** Optional host-owned decision model, exposed alongside tools.read. */
+    decision?: DecisionToolOptions;
 }): Promise<import("./host.js").ToolHost>;

package/dist/skills-host.js

@@ -3,6 +3,7 @@ import { createToolHost } from './host.js';
 import { createSkillsServer } from './skills-server.js';
 import { mountMcpSdk } from './mcp-sdk-source.js';
 import { createReadTool, createMcpReadResolver, mcpResourceAddress } from './read.js';
+import { createDecisionTool } from './decision.js';
 /** Ready-to-run local host. The skills service owns collections and discovery;
  * the host imports its single list tool through the ordinary MCP adapter.
  */
@@ -28,7 +29,10 @@ export async function createSkillsHost(options) {
                 return { ...result, structuredContent: { entries: scoped }, content: [{ type: 'text', text: JSON.stringify(scoped) }] };
             },
         });
-        await host.register('tools', { read: createReadTool({ cwd: options.cwd, resolvers: { mcp: createMcpReadResolver({ skills: source }) } }) }, {
+        await host.register('tools', {
+            read: createReadTool({ cwd: options.cwd, resolvers: { mcp: createMcpReadResolver({ skills: source }) } }),
+            ...(options.decision ? { decision: createDecisionTool(options.decision) } : {}),
+        }, {
             dispose: async () => { if (timer)
                 clearInterval(timer); await service.close(); },
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oh-my-ai-sdk/omakase",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "type": "module",
   "description": "One Code Mode tool host for native AI SDK agents and MCP clients, with a stateful skills service",
   "exports": {