@oxy.so/contracts 4.6.0 → 4.7.0

package/dist/esm/agency.js

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { catalogInvocationPathParameters, findOverlappingCatalogInvocations, } from './capabilityInvocation.js';
 const nonEmptyStringSchema = z.string().trim().min(1);
 const identifierSchema = z.string().trim().min(1).max(255);
 const limitKeySchema = z.string().regex(/^[A-Za-z][A-Za-z0-9_]*(?:\.[A-Za-z][A-Za-z0-9_]*)*$/, 'limit keys must be dot-separated input property names').max(255);
@@ -346,6 +347,42 @@ export const catalogToolSchema = z.object({
             path: ['invocation', 'method'],
         });
     }
+    // The invocation template is how a coordinator turns arguments into a
+    // request (`resolveCatalogInvocation`). A `{param}` the input schema does
+    // not declare as a REQUIRED property can never be filled, and a GET input
+    // that is not a scalar has no query-string form — both are refused here so
+    // the builder never has to guess.
+    const declared = typeof tool.inputSchema.properties === 'object'
+        && tool.inputSchema.properties !== null
+        && !Array.isArray(tool.inputSchema.properties)
+        ? tool.inputSchema.properties
+        : {};
+    const required = Array.isArray(tool.inputSchema.required) ? tool.inputSchema.required : [];
+    const parameters = catalogInvocationPathParameters(tool.invocation.path);
+    requireUnique(parameters, 'invocation.path parameters');
+    for (const parameter of parameters) {
+        if (!Object.prototype.hasOwnProperty.call(declared, parameter) || !required.includes(parameter)) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `Path parameter {${parameter}} must be a required input property`,
+                path: ['invocation', 'path'],
+            });
+        }
+    }
+    if (tool.invocation.method === 'GET') {
+        for (const [key, property] of Object.entries(declared)) {
+            const type = typeof property === 'object' && property !== null
+                ? property.type
+                : undefined;
+            if (type !== 'string' && type !== 'number' && type !== 'integer' && type !== 'boolean') {
+                context.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    message: `GET input ${key} must be a string, number, integer or boolean`,
+                    path: ['inputSchema', 'properties', key],
+                });
+            }
+        }
+    }
 });
 export const catalogEventSchema = z.object({
     type: identifierSchema,
@@ -413,6 +450,18 @@ export const appCapabilityCatalogSchema = z.object({
         }
         names.add(tool.name);
     }
+    // Matching an incoming request back to its tool must have ONE answer that
+    // does not depend on the order tools are listed in — see
+    // `matchCatalogInvocation`. Two templates that one request could satisfy
+    // (`/messages/{id}` beside `/messages/unread`) make that impossible.
+    for (const [left, right] of findOverlappingCatalogInvocations(catalog.tools)) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `Tools ${left.name} and ${right.name} have overlapping invocations `
+                + `(${left.invocation.method} ${left.invocation.path} / ${right.invocation.method} ${right.invocation.path})`,
+            path: ['tools'],
+        });
+    }
     const eventTypes = new Set();
     for (const [index, event] of catalog.events.entries()) {
         if (eventTypes.has(event.type)) {

package/dist/esm/capabilityInvocation.js

@@ -0,0 +1,165 @@
+/**
+ * How a catalog tool call travels over HTTP, in both directions.
+ *
+ * A capability catalog names each tool's `invocation` as a method plus a path
+ * template (`/email/messages/{emailId}`). Two parties have to agree on what
+ * that means: the coordinator that BUILDS the request from the model's
+ * arguments (Alia), and the app that MATCHES an incoming request back to the
+ * one tool its ticket was signed for (the Inbox capability middleware). Each
+ * used to carry its own copy of the rules, and the matcher walked the tool list
+ * in array order, so a literal segment (`/messages/unread`) and a parameter
+ * (`/messages/{id}`) in the same position resolved to whichever tool happened to
+ * be declared first. Both halves live here now, next to the catalog schema that
+ * refuses a catalog whose templates could ever match the same request — so a
+ * match is unique by construction, not by ordering.
+ */
+const PARAMETER_SEGMENT = /^\{([A-Za-z][A-Za-z0-9_]*)\}$/;
+function pathSegments(path) {
+    return path.split('/').filter(Boolean);
+}
+/** The `{name}` placeholders of a path template, in order. */
+export function catalogInvocationPathParameters(path) {
+    return pathSegments(path).flatMap((segment) => {
+        const parameter = PARAMETER_SEGMENT.exec(segment)?.[1];
+        return parameter ? [parameter] : [];
+    });
+}
+/**
+ * Whether one concrete request could match BOTH templates.
+ *
+ * Same method, same number of segments, and at every position either the same
+ * literal or a parameter on at least one side. `/messages/{id}` and
+ * `/messages/unread` overlap (the request `/messages/unread` fits both);
+ * `/messages/{id}` and `/messages/{id}/thread` do not.
+ */
+export function catalogInvocationsOverlap(left, right) {
+    if (left.method.toUpperCase() !== right.method.toUpperCase())
+        return false;
+    const leftSegments = pathSegments(left.path);
+    const rightSegments = pathSegments(right.path);
+    if (leftSegments.length !== rightSegments.length)
+        return false;
+    return leftSegments.every((segment, index) => {
+        const other = rightSegments[index] ?? '';
+        return segment === other || PARAMETER_SEGMENT.test(segment) || PARAMETER_SEGMENT.test(other);
+    });
+}
+/**
+ * Whether two templates name the same ADDRESS: same method, and at every
+ * position the same literal or a parameter on both sides — parameter names do
+ * not matter (`/messages/{id}` and `/messages/{emailId}` are one address;
+ * `/messages/{id}` and `/messages/bundled` are not, though they overlap).
+ * Used to say which documented REST operation shares its address with a tool.
+ */
+export function catalogInvocationTemplatesEquivalent(left, right) {
+    if (left.method.toUpperCase() !== right.method.toUpperCase())
+        return false;
+    const leftSegments = pathSegments(left.path);
+    const rightSegments = pathSegments(right.path);
+    if (leftSegments.length !== rightSegments.length)
+        return false;
+    return leftSegments.every((segment, index) => {
+        const other = rightSegments[index] ?? '';
+        const leftIsParameter = PARAMETER_SEGMENT.test(segment);
+        return leftIsParameter ? PARAMETER_SEGMENT.test(other) : segment === other;
+    });
+}
+/** Every pair of tools whose invocations overlap — empty for a valid catalog. */
+export function findOverlappingCatalogInvocations(tools) {
+    const overlaps = [];
+    for (let left = 0; left < tools.length; left += 1) {
+        for (let right = left + 1; right < tools.length; right += 1) {
+            const a = tools[left];
+            const b = tools[right];
+            if (a && b && catalogInvocationsOverlap(a.invocation, b.invocation))
+                overlaps.push([a, b]);
+        }
+    }
+    return overlaps;
+}
+function matchTemplate(template, method, requestSegments) {
+    if (template.method.toUpperCase() !== method.toUpperCase())
+        return null;
+    const templateSegments = pathSegments(template.path);
+    if (templateSegments.length !== requestSegments.length)
+        return null;
+    const params = {};
+    for (const [index, templateSegment] of templateSegments.entries()) {
+        const requestSegment = requestSegments[index];
+        if (!requestSegment)
+            return null;
+        const parameter = PARAMETER_SEGMENT.exec(templateSegment)?.[1];
+        if (!parameter) {
+            if (templateSegment !== requestSegment)
+                return null;
+            continue;
+        }
+        try {
+            params[parameter] = decodeURIComponent(requestSegment);
+        }
+        catch {
+            return null;
+        }
+    }
+    return params;
+}
+/**
+ * The ONE tool whose invocation matches `method` + `path` (the full app-local
+ * path, e.g. `/email/messages/abc`), or null.
+ *
+ * Every tool is tried, not the first hit, so the answer cannot depend on the
+ * order the catalog lists its tools in. A second hit means the catalog should
+ * never have validated — `appCapabilityCatalogSchema` refuses overlapping
+ * templates — so it throws rather than guessing which tool the ticket meant.
+ */
+export function matchCatalogInvocation(tools, method, path) {
+    const requestSegments = pathSegments(path);
+    const matches = [];
+    for (const tool of tools) {
+        const params = matchTemplate(tool.invocation, method, requestSegments);
+        if (params)
+            matches.push({ tool, params });
+    }
+    if (matches.length > 1) {
+        throw new Error(`Ambiguous catalog invocation ${method} ${path}: ${matches.map(({ tool }) => tool.name).join(', ')}`);
+    }
+    return matches[0] ?? null;
+}
+/**
+ * Build the HTTP request for a tool call from the model's arguments.
+ *
+ * Path parameters are substituted (and removed from the remaining arguments);
+ * GET sends the rest as query parameters, everything else as a JSON body. A GET
+ * argument that is not a scalar is refused instead of being stringified into
+ * `[object Object]` — the catalog schema only lets GET tools declare scalar
+ * inputs, so reaching that branch means the arguments did not come from the
+ * tool's own schema. The resolved URL must stay on `internalBaseUrl`'s origin.
+ */
+export function resolveCatalogInvocation(catalog, tool, args) {
+    const remaining = { ...args };
+    const path = tool.invocation.path.replace(/\{(\w+)\}/g, (_match, parameter) => {
+        const value = Object.prototype.hasOwnProperty.call(remaining, parameter) ? remaining[parameter] : undefined;
+        delete remaining[parameter];
+        if (value === undefined || value === null || value === '') {
+            throw new Error(`Missing required path parameter: ${parameter}`);
+        }
+        return encodeURIComponent(String(value));
+    });
+    const baseUrl = new URL(catalog.internalBaseUrl);
+    const url = new URL(path, `${baseUrl.origin}/`);
+    if (url.origin !== baseUrl.origin) {
+        throw new Error(`Catalog invocation for ${tool.name} escapes its registered app origin`);
+    }
+    const method = tool.invocation.method.toUpperCase();
+    if (method !== 'GET')
+        return { method, url, body: remaining };
+    for (const [key, value] of Object.entries(remaining)) {
+        if (value === undefined || value === null)
+            continue;
+        if (typeof value !== 'string' && typeof value !== 'number' && typeof value !== 'boolean') {
+            throw new Error(`GET argument ${key} of ${tool.name} must be a string, number or boolean`);
+        }
+        url.searchParams.set(key, String(value));
+    }
+    return { method, url };
+}

package/dist/esm/index.js

@@ -174,6 +174,7 @@ export {
 // decimal, so a plan allowance cannot be added to a balance.
 PRODUCT_PLAN_STATUSES, productPlanStatusSchema, LIVE_PRODUCT_PLAN_STATUSES, planAllowanceSchema, productPlanSchema, payAsYouGoEntitlementSchema, COST_CENTER_STATUSES, costCenterStatusSchema, costCenterSchema, costCenterSpendSchema, productEntitlementSchema, } from './inference/entitlement.js';
 export { AUTONOMY_LEVELS, CAPABILITY_PACKAGES, autonomyLevelSchema, capabilityPackageSchema, actorRefSchema, resourceRefSchema, toolGrantOverrideSchema, grantLimitSchema, capabilityCatalogBindingSchema, executionAuthorizationRefSchema, capabilityCoordinatorSchema, delegationGrantSchema, automationTriggerSchema, automationActorSelectionSchema, automationDataFlowSchema, automationDefinitionSchema, capabilityTicketClaimsSchema, policyDecisionSchema, auditResultSchema, auditEventSchema, catalogToolSchema, catalogEventSchema, appCapabilityCatalogSchema, catalogRegistrationSchema, normalizedAppEventSchema, } from './agency.js';
+export { catalogInvocationPathParameters, catalogInvocationsOverlap, catalogInvocationTemplatesEquivalent, findOverlappingCatalogInvocations, matchCatalogInvocation, resolveCatalogInvocation, } from './capabilityInvocation.js';
 export { emailContextAddressSchema, emailContextMailboxSchema, emailContextMessageSchema, emailAgentContextSchema, } from './emailAgentContext.js';
 export { inboxComposeRequestSchema, inboxDailyBriefRequestSchema, inboxNaturalSearchRequestSchema, inboxMessageInferenceParamsSchema, inboxInferenceTextResponseSchema, inboxNaturalSearchResponseSchema, inboxSmartRepliesResponseSchema, inboxThreadSummaryResponseSchema, inboxInferenceStreamEventSchema, } from './inference/inbox.js';
 export * from './externalIdentity.js';
@@ -182,3 +183,4 @@ export * from './federationInstanceFetch.js';
 export * from './notifications.js';
 export * from './email/messages.js';
 export * from './stickers.js';
+export { decisionEffortSchema, decisionQuestionSchema, decisionInputSchema, decisionRequestSchema, decisionAnswerSchema, decisionResultSchema, decisionSuccessSchema, decisionFailureSchema, decisionInputBudget, decisionFitsGateway, decisionAnswersMatch, } from './inference/decisions.js';

package/dist/esm/inference/catalogue.js

@@ -55,7 +55,8 @@ export const reasoningEffortSchema = z.enum(['low', 'medium', 'high']);
  * 3.4.0). Ordered cheapest first; `auto` asks Oxy to pick the cheapest level
  * that suffices for the request.
  *
- * - `instant` — very cheap, fast small models; no reasoning effort requested
+ * - `instant` — very cheap, fast small models; the least reasoning each model
+ *   accepts (`low` on a reasoning model, nothing on one without effort control)
  * - `medium` — mid-size models, low reasoning effort
  * - `high` — strong models, medium reasoning effort
  * - `xhigh` — strong models, high reasoning effort
@@ -93,6 +94,7 @@ export const inferenceApiFormatSchema = z.enum([
     'responses',
     'chat_completions',
     'embeddings',
+    'decisions',
     'images_generations',
     'audio_transcriptions',
     'audio_speech',
@@ -580,7 +582,9 @@ export const routingProfileSchema = z.object({
     powerLevel: powerLevelSchema.optional(),
     /**
      * The reasoning effort a power level asks for when the request names none,
-     * applied only on a model that advertises it. Absent: none is requested.
+     * clamped to the nearest effort the chosen model accepts (the lowest at or
+     * above it, else the highest). Absent: the level asks for no reasoning, sent
+     * as the least effort a reasoning model accepts.
      */
     reasoningEffort: reasoningEffortSchema.optional(),
 });

package/dist/esm/inference/decisions.js

@@ -0,0 +1,239 @@
+import { z } from "zod";
+import { inferenceErrorSchema } from "./errors.js";
+import { modelReferenceSchema, requestIdSchema } from "./identifiers.js";
+import { usageQuantitySchema } from "./money.js";
+import { routingPolicyReferenceSchema } from "./routingPolicy.js";
+import { normalizedUsageReportSchema } from "./usage.js";
+const probability = z.number().finite().min(0).max(1);
+const text = z.string().min(1).max(65536);
+const id = z.string().min(1).max(128);
+const tolerance = 1e-6;
+export const decisionEffortSchema = z.enum([
+    "instant",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+]);
+const common = { id, question: text, criteria: text.optional() };
+export const decisionQuestionSchema = z.discriminatedUnion("kind", [
+    z
+        .object({
+        ...common,
+        kind: z.literal("choice"),
+        options: z.array(text).min(2).max(255),
+    })
+        .strict(),
+    z
+        .object({
+        ...common,
+        kind: z.literal("score"),
+        levels: z.array(text).min(2).max(10),
+    })
+        .strict(),
+    z.object({ ...common, kind: z.literal("noul") }).strict(),
+]);
+const payloadFields = {
+    state: z.string().max(65536),
+    instructions: text.optional(),
+    questions: z.array(decisionQuestionSchema).min(1).max(255),
+    effort: decisionEffortSchema.optional(),
+};
+/**
+ * Conservative serialized input accounting, including escaping and structure.
+ * Measures both the normalized payload and the provider's structured-question
+ * representation. Common instructions repeat per question there. A 255-byte
+ * model identity and 4096-byte gateway-policy allowance bound adapter metadata.
+ * Kaana must also check its final serialized body before sending it.
+ */
+export function decisionInputBudget(payload) {
+    const bytes = (value) => new TextEncoder().encode(JSON.stringify(value).replace(/[<>&\u2028\u2029]/g, (char) => `\\u${char.charCodeAt(0).toString(16).padStart(4, "0")}`)).length;
+    const model = "x".repeat(255);
+    const measure = (questions) => {
+        const wireQuestions = Object.fromEntries(questions.map((q) => [q.id, {
+                type: q.kind,
+                instructions: {
+                    question: q.question,
+                    ...(payload.instructions === undefined ? {} : { instructions: payload.instructions }),
+                    ...(q.criteria === undefined ? {} : { criteria: q.criteria }),
+                },
+                ...(q.kind === "choice" ? { criteria: Object.fromEntries(q.options.map((label) => [label, null])) } :
+                    q.kind === "score" ? { criteria: q.levels } : {}),
+            }]));
+        return Math.max(bytes({ ...payload, model, questions }), bytes({ model, state: payload.state, questions: wireQuestions, ...(payload.effort === undefined ? {} : { effort: payload.effort }) }));
+    };
+    const total = measure(payload.questions);
+    return { total, context: Math.max(...payload.questions.map((q) => measure([q]))), gateway: total + 4096 };
+}
+/** OpenRouter's TOTAL limit is separate from direct state-plus-longest context. */
+export function decisionFitsGateway(payload) {
+    return decisionInputBudget(payload).gateway <= 32000;
+}
+function validateInput(payload, ctx) {
+    if (new Set(payload.questions.map((q) => q.id)).size !==
+        payload.questions.length)
+        ctx.addIssue({
+            code: "custom",
+            path: ["questions"],
+            message: "Question IDs must be unique.",
+        });
+    for (const [index, question] of payload.questions.entries()) {
+        const labels = question.kind === "choice"
+            ? question.options
+            : question.kind === "score"
+                ? question.levels
+                : [];
+        if (new Set(labels).size !== labels.length)
+            ctx.addIssue({
+                code: "custom",
+                path: ["questions", index],
+                message: "Options and levels must be unique.",
+            });
+    }
+    const budget = decisionInputBudget(payload);
+    if (budget.total > 64000 || budget.context > 32000)
+        ctx.addIssue({
+            code: "custom",
+            path: ["state"],
+            message: "Decisions exceed the serialized 64000-byte total or 32000-byte per-question context budget.",
+        });
+}
+export const decisionInputSchema = z
+    .object(payloadFields)
+    .strict()
+    .superRefine(validateInput);
+export const decisionRequestSchema = z
+    .object({
+    model: modelReferenceSchema.refine((model) => model.includes("@"), "Decisions require a revision-pinned model."),
+    ...payloadFields,
+})
+    .strict()
+    .superRefine(validateInput);
+export const decisionAnswerSchema = z
+    .discriminatedUnion("kind", [
+    z
+        .object({
+        id,
+        kind: z.literal("choice"),
+        /** Actual provider-selected option. Never reconstructed from probabilities. */
+        reply: text,
+        /** Provider-returned confidence, not a correctness probability. */
+        confidence: probability,
+        probabilities: z.array(probability).min(2).max(255),
+    })
+        .strict(),
+    z
+        .object({
+        id,
+        kind: z.literal("score"),
+        /** Actual provider score. Kept separate from the validated expected index. */
+        reply: z.number().finite().min(0).max(9),
+        confidence: probability,
+        mean: z.number().finite().min(0).max(9),
+        distribution: z.array(probability).min(2).max(10),
+    })
+        .strict(),
+    z.object({ id, kind: z.literal("noul"), probability }).strict(),
+])
+    .superRefine((answer, ctx) => {
+    if (answer.kind === "noul")
+        return;
+    if (answer.kind === "score" && Math.abs(answer.reply - answer.mean) > tolerance) {
+        ctx.addIssue({ code: "custom", path: ["reply"], message: "Provider score must match the expected level index." });
+    }
+    const distribution = answer.kind === "choice" ? answer.probabilities : answer.distribution;
+    if (Math.abs(distribution.reduce((sum, value) => sum + value, 0) - 1) >
+        tolerance)
+        ctx.addIssue({
+            code: "custom",
+            message: "Probabilities must sum to one.",
+        });
+    if (answer.kind === "score" &&
+        Math.abs(distribution.reduce((sum, value, index) => sum + index * value, 0) -
+            answer.mean) > tolerance)
+        ctx.addIssue({
+            code: "custom",
+            path: ["mean"],
+            message: "Mean must equal the expected zero-based level index.",
+        });
+});
+const resultFields = {
+    schemaVersion: z.literal(1),
+    requestId: requestIdSchema,
+    model: modelReferenceSchema.refine((model) => model.includes("@"), "Decisions require an immutable model revision."),
+    data: z.array(decisionAnswerSchema).min(1).max(255),
+};
+function uniqueAnswers(result, ctx) {
+    if (new Set(result.data.map((answer) => answer.id)).size !== result.data.length)
+        ctx.addIssue({
+            code: "custom",
+            path: ["data"],
+            message: "Answer IDs must be unique.",
+        });
+}
+export const decisionResultSchema = z
+    .object({ ...resultFields, usage: normalizedUsageReportSchema })
+    .strict()
+    .superRefine(uniqueAnswers)
+    .superRefine((result, ctx) => {
+    if (result.usage.requestId !== result.requestId ||
+        result.usage.resolvedModelReference !== result.model ||
+        result.usage.outcome !== "completed") {
+        ctx.addIssue({
+            code: "custom",
+            path: ["usage"],
+            message: "Decision usage must describe this completed request and immutable model.",
+        });
+    }
+});
+/**
+ * Kaana's typed decisions failure. `usage` is present only when the provider
+ * measured something before failing; its absence means nothing was measured,
+ * never that the cost was zero. A failure carrying usage did execute.
+ */
+export const decisionFailureSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    requestId: requestIdSchema,
+    error: inferenceErrorSchema,
+    usage: normalizedUsageReportSchema.optional(),
+})
+    .strict()
+    .superRefine((failure, ctx) => {
+    if (failure.error.requestId !== failure.requestId) {
+        ctx.addIssue({ code: "custom", path: ["error", "requestId"], message: "The error must answer this request." });
+    }
+    if (failure.usage !== undefined &&
+        (failure.usage.requestId !== failure.requestId || failure.usage.outcome === "completed")) {
+        ctx.addIssue({ code: "custom", path: ["usage"], message: "Failure usage must describe this request and an incomplete outcome." });
+    }
+});
+export const decisionSuccessSchema = z
+    .object({
+    ...resultFields,
+    usage: z.array(usageQuantitySchema),
+    routingPolicy: routingPolicyReferenceSchema,
+})
+    .strict()
+    .superRefine(uniqueAnswers);
+/** Bind output to the exact request. Provider order is not semantic. */
+export function decisionAnswersMatch(input, answers) {
+    if (answers.length !== input.questions.length ||
+        new Set(answers.map((a) => a.id)).size !== answers.length)
+        return false;
+    return input.questions.every((question) => {
+        const answer = answers.find((candidate) => candidate.id === question.id);
+        if (!answer ||
+            !decisionAnswerSchema.safeParse(answer).success ||
+            answer.kind !== question.kind)
+            return false;
+        if (question.kind === "choice" && answer.kind === "choice") {
+            const index = question.options.indexOf(answer.reply);
+            return question.options.length === answer.probabilities.length && index >= 0 &&
+                answer.probabilities[index] + tolerance >= Math.max(...answer.probabilities);
+        }
+        if (question.kind === "score" && answer.kind === "score")
+            return question.levels.length === answer.distribution.length;
+        return question.kind === "noul";
+    });
+}

package/dist/esm/inference/request.js

@@ -23,6 +23,7 @@
  * Decided in: docs/adr/0010-public-api-compatibility.md,
  * docs/adr/0017-authorized-routes-in-the-envelope.md.
  */
+import { decisionInputSchema } from './decisions.js';
 import { z } from "zod";
 import { inferenceAttributionSchema } from "./attribution.js";
 import { inferenceApiFormatSchema, inferenceModalitySchema, reasoningEffortSchema, } from "./catalogue.js";
@@ -195,6 +196,7 @@ export const inferenceMessageSchema = z
  * that both metering and provider translation depend on.
  */
 export const inferenceInputSchema = z.discriminatedUnion("format", [
+    z.object({ format: z.literal("decisions"), decisions: decisionInputSchema }).strict(),
     z
         .object({
         format: z.literal("messages"),
@@ -403,6 +405,17 @@ export const inferenceRequestSchema = z
     authorizedRoutes: z.array(authorizedRouteSchema).min(1).optional(),
 })
     .superRefine((request, ctx) => {
+    if (request.input.format === "decisions" || request.client.apiFormat === "decisions") {
+        const exactModel = request.target.kind === "model" && request.target.modelReference.includes('@');
+        const foreignRoute = request.authorizedRoutes?.some((route) => request.target.kind !== "model" || route.modelReference !== request.target.modelReference || route.substitution !== "same_model");
+        if (request.input.format !== "decisions" || request.client.apiFormat !== "decisions" ||
+            request.modality !== "text" || request.stream || !exactModel || foreignRoute ||
+            request.maxOutputTokens !== undefined || Object.keys(request.sampling).length > 0 ||
+            request.tools.length > 0 || request.toolChoice !== undefined || request.responseFormat !== undefined ||
+            request.reasoning !== undefined || request.speech !== undefined || request.audioOutput !== undefined) {
+            ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["input"], message: "Decisions require exact-model typed nonstreaming input without generation controls or model substitution." });
+        }
+    }
     const isSpeech = request.client.apiFormat === "audio_speech";
     if (isSpeech && request.speech !== undefined && (request.modality !== "audio" || request.input.format !== "text" || request.stream)) {
         ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["speech"], message: "speech requires audio modality, text input, parameters and non-streaming output" });

package/dist/esm/inference/version.js

@@ -99,4 +99,4 @@
  * change to, say, the catalogue reject every in-flight inference request; the
  * per-shape `schemaVersion` is what a message is validated against.
  */
-export const INFERENCE_CONTRACT_VERSION = '3.4.0';
+export const INFERENCE_CONTRACT_VERSION = '3.5.0';