@cat-factory/contracts 0.211.0 → 0.213.0

package/dist/binary-generators.d.ts

@@ -0,0 +1,142 @@
+import * as v from 'valibot';
+/**
+ * A credential a generative integration needs, declared by NAME only — never a value.
+ *
+ * The value is resolved per dispatch through the facade-wired `ToolSecretResolver` port (the
+ * same port a tool server's credentials go through) and written straight onto the job body,
+ * where the harness injects it into THIS JOB's agent environment. It never reaches
+ * `AgentRunContext`, a prompt, or the telemetry snapshot — only the key NAME does, because the
+ * agent has to know which variable to read.
+ */
+export declare const binaryGeneratorCredentialSchema: v.ObjectSchema<{
+    /**
+     * The credential's key. It is both what the secret resolver is asked for and the ENVIRONMENT
+     * VARIABLE the agent reads it from, so it must be a valid POSIX variable name — a generator
+     * declaring `x-rd-token` would resolve fine and then be dropped by the harness's env
+     * validation, which is a silent "the integration just 401s" at run time.
+     */
+    readonly key: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 128, undefined>, v.RegexAction<string, "must be a valid environment variable name">]>;
+    /**
+     * How the integration expects the credential to be presented (`X-RD-Token: <value>`,
+     * `Authorization: Bearer <value>`). Folded into the brief verbatim: the agent writes the
+     * request itself, and a key with no stated header is a key it has to guess the use of.
+     */
+    readonly usage: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MaxLengthAction<string, 400, undefined>]>, undefined>;
+    /**
+     * When true (the default), an integration whose credential does not resolve is reported to
+     * the agent as UNAVAILABLE rather than offered. Set false only for an endpoint that genuinely
+     * works unauthenticated — an agent handed an API whose first call 401s burns a run
+     * discovering it.
+     */
+    readonly required: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+}, undefined>;
+export type BinaryGeneratorCredential = v.InferOutput<typeof binaryGeneratorCredentialSchema>;
+/**
+ * A generative binary integration a deployment registers in code.
+ *
+ * Shaped like a foundational service on purpose — identity, prose, and API contracts in the
+ * SAME `uploadApiContractSchema` vocabulary — so one contract renderer serves both and a
+ * deployment writes one kind of definition. What it adds is what a GENERATOR has and a shared
+ * service does not: the content types it produces, and the credential it needs.
+ */
+export declare const binaryGeneratorDefinitionSchema: v.ObjectSchema<{
+    /** Stable id, referenced by a step's `stepOptions.binaryOutput.generatorIds`. */
+    readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 64, undefined>, v.RegexAction<string, "must be a lower-kebab slug">]>;
+    readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 200, undefined>]>;
+    /** One line, shown in the picker and the agent's brief. */
+    readonly summary: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 400, undefined>]>;
+    /**
+     * What it is good at and what it is NOT for — style, resolution/length limits, cost profile.
+     * The half a model needs to pick between two registered generators of the same modality.
+     */
+    readonly description: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MaxLengthAction<string, 20000, undefined>]>;
+    /**
+     * The content types it produces. At least one: a generator that produces nothing is not a
+     * generator, and an empty list would make it match every step's requirements by vacuity.
+     */
+    readonly modalities: v.SchemaWithPipe<readonly [v.ArraySchema<v.PicklistSchema<["image", "audio", "video", "3d", "document"], undefined>, undefined>, v.MinLengthAction<("3d" | "audio" | "document" | "image" | "video")[], 1, undefined>]>;
+    /**
+     * The concrete media types it can emit (`image/png`, `audio/mpeg`), when the integration
+     * pins them down. Absent ⇒ only the coarse {@link modalities} are known, which the brief
+     * states as such rather than implying every format of that modality is available.
+     */
+    readonly mediaTypes: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.ToLowerCaseAction, v.MinLengthAction<string, 3, undefined>, v.MaxLengthAction<string, 128, undefined>, v.RegexAction<string, "must be a media type of the form type/subtype">]>, undefined>, undefined>;
+    /**
+     * The API's base URL. Stated to the agent so it does not have to infer one from the contract,
+     * and refused at registration unless it is `https` (or loopback) — the credential above rides
+     * this request.
+     */
+    readonly endpoint: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 2048, undefined>]>, undefined>;
+    /**
+     * Operating notes folded into the agent's brief verbatim — polling an async job, the shape of
+     * a returned payload (base64 vs a signed URL), a rate limit worth respecting. This is where a
+     * deployment puts the knowledge that would otherwise be discovered once per run.
+     */
+    readonly guidance: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MaxLengthAction<string, 20000, undefined>]>, undefined>;
+    readonly credential: v.OptionalSchema<v.ObjectSchema<{
+        /**
+         * The credential's key. It is both what the secret resolver is asked for and the ENVIRONMENT
+         * VARIABLE the agent reads it from, so it must be a valid POSIX variable name — a generator
+         * declaring `x-rd-token` would resolve fine and then be dropped by the harness's env
+         * validation, which is a silent "the integration just 401s" at run time.
+         */
+        readonly key: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 128, undefined>, v.RegexAction<string, "must be a valid environment variable name">]>;
+        /**
+         * How the integration expects the credential to be presented (`X-RD-Token: <value>`,
+         * `Authorization: Bearer <value>`). Folded into the brief verbatim: the agent writes the
+         * request itself, and a key with no stated header is a key it has to guess the use of.
+         */
+        readonly usage: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MaxLengthAction<string, 400, undefined>]>, undefined>;
+        /**
+         * When true (the default), an integration whose credential does not resolve is reported to
+         * the agent as UNAVAILABLE rather than offered. Set false only for an endpoint that genuinely
+         * works unauthenticated — an agent handed an API whose first call 401s burns a run
+         * discovering it.
+         */
+        readonly required: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+    }, undefined>, undefined>;
+    /**
+     * The integration's API contract documents, in the same formats the foundational catalog
+     * accepts. Injected as `.cat-context/` files beside the brief, so the agent calls the
+     * operations the contract declares instead of inventing them.
+     */
+    readonly contracts: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+        readonly contractId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 64, undefined>, v.RegexAction<string, "must be a lower-kebab slug">]>;
+        readonly format: v.PicklistSchema<["openapi", "toad-contract", "lokalise-api-contract"], undefined>;
+        readonly title: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 200, undefined>]>;
+        readonly body: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 1000000, undefined>]>;
+    }, undefined>, undefined>, undefined>;
+}, undefined>;
+export type BinaryGeneratorDefinition = v.InferOutput<typeof binaryGeneratorDefinitionSchema>;
+/**
+ * The ways `definition` fails {@link binaryGeneratorDefinitionSchema}, as readable lines — empty
+ * when it would be accepted.
+ *
+ * Exists for the same reason `foundationalServiceDefinitionIssues` does: the backend layers that
+ * hold a deployment's CODE-registered definitions to this shape (kernel, orchestration's boot
+ * validation) cannot depend on valibot, and re-stating the rules in a second place is how a
+ * registration ends up accepted where an equivalent one is refused.
+ */
+/**
+ * A registered integration as the WIRE carries it to the SPA (the workspace snapshot's
+ * `binaryGenerators`), so the pipeline builder can offer a step's `generatorIds` from the same
+ * set run admission validates against instead of asking a human to type an id.
+ *
+ * IDENTITY ONLY, and the omissions are the point. The credential's key NAME is left out — the
+ * picker has no use for it, and a workspace VIEWER has no business learning which environment
+ * variables the deployment sets. So are the contracts and the endpoint: they are the agent's
+ * interface to the integration, delivered as injected `.cat-context/` files at dispatch, and
+ * nothing a person picking from a list needs.
+ */
+export declare const registeredBinaryGeneratorSchema: v.ObjectSchema<{
+    readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 64, undefined>, v.RegexAction<string, "must be a lower-kebab slug">]>;
+    readonly name: v.StringSchema<undefined>;
+    readonly summary: v.StringSchema<undefined>;
+    /** What it produces — what the builder checks a step's declared content types against. */
+    readonly modalities: v.ArraySchema<v.PicklistSchema<["image", "audio", "video", "3d", "document"], undefined>, undefined>;
+    /** The concrete formats it pins down, when it declares any. Shown as detail, never a filter. */
+    readonly mediaTypes: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.ToLowerCaseAction, v.MinLengthAction<string, 3, undefined>, v.MaxLengthAction<string, 128, undefined>, v.RegexAction<string, "must be a media type of the form type/subtype">]>, undefined>, undefined>;
+}, undefined>;
+export type RegisteredBinaryGenerator = v.InferOutput<typeof registeredBinaryGeneratorSchema>;
+export declare function binaryGeneratorDefinitionIssues(definition: unknown): string[];
+//# sourceMappingURL=binary-generators.d.ts.map

package/dist/binary-generators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binary-generators.d.ts","sourceRoot":"","sources":["../src/binary-generators.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAgC5B;;;;;;;;GAQG;AACH,eAAO,MAAM,+BAA+B;IAC1C;;;;;OAKG;;IAQH;;;;OAIG;;IAEH;;;;;OAKG;;aAEH,CAAA;AACF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,+BAA+B,CAAC,CAAA;AAE7F;;;;;;;GAOG;AACH,eAAO,MAAM,+BAA+B;IAC1C,iFAAiF;;;IAGjF,2DAA2D;;IAE3D;;;OAGG;;IAEH;;;OAGG;;IAEH;;;;OAIG;;IAEH;;;;OAIG;;IAEH;;;;OAIG;;;QArEH;;;;;WAKG;;QAQH;;;;WAIG;;QAEH;;;;;WAKG;;;IAgDH;;;;OAIG;;;;;;;aAEH,CAAA;AACF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,+BAA+B,CAAC,CAAA;AAE7F;;;;;;;;GAQG;AACH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,+BAA+B;;;;IAI1C,0FAA0F;;IAE1F,gGAAgG;;aAEhG,CAAA;AACF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,+BAA+B,CAAC,CAAA;AAE7F,wBAAgB,+BAA+B,CAAC,UAAU,EAAE,OAAO,GAAG,MAAM,EAAE,CAO7E"}

package/dist/binary-generators.js

@@ -0,0 +1,143 @@
+import * as v from 'valibot';
+import { binaryModalitySchema, mediaTypeSchema } from './binary-modalities.js';
+import { uploadApiContractSchema } from './foundational-services.js';
+// ---------------------------------------------------------------------------
+// Wire vocabulary for GENERATIVE BINARY INTEGRATIONS — the third-party (or in-house) APIs a
+// binary-generating agent kind calls to PRODUCE its deliverable: an image generator, a
+// music/speech generator, a video generator.
+//
+// This is the missing half of `binary-outputs.ts`. That module answers "where does a generated
+// artifact GO" (a foundational service the org runs, carrying the `asset-storage` capability);
+// this one answers "what MAKES it". The two are deliberately separate registries because they
+// are separate facts about an org: the storage estate is shared infrastructure every designed
+// system consumes, while a generation integration is a vendor a deployment buys and points at
+// specific steps. Modelling a generator as a foundational service would put a metered vendor
+// API into the catalog an Architect designs AGAINST, where it would be offered to every design
+// step as something to build on.
+//
+// A generator is registered in a deployment's CODE, on the app-owned `BinaryGeneratorRegistry`
+// (kernel), exactly as it registers agent kinds, gates, pipelines or its foundational estate —
+// so it needs no table, no migration and no UI, and both runtime facades get identical
+// behaviour by building the same registry.
+// ---------------------------------------------------------------------------
+const slug = v.pipe(v.string(), v.trim(), v.minLength(1), v.maxLength(64), v.regex(/^[a-z0-9][a-z0-9-]*$/, 'must be a lower-kebab slug'));
+/**
+ * A credential a generative integration needs, declared by NAME only — never a value.
+ *
+ * The value is resolved per dispatch through the facade-wired `ToolSecretResolver` port (the
+ * same port a tool server's credentials go through) and written straight onto the job body,
+ * where the harness injects it into THIS JOB's agent environment. It never reaches
+ * `AgentRunContext`, a prompt, or the telemetry snapshot — only the key NAME does, because the
+ * agent has to know which variable to read.
+ */
+export const binaryGeneratorCredentialSchema = v.object({
+    /**
+     * The credential's key. It is both what the secret resolver is asked for and the ENVIRONMENT
+     * VARIABLE the agent reads it from, so it must be a valid POSIX variable name — a generator
+     * declaring `x-rd-token` would resolve fine and then be dropped by the harness's env
+     * validation, which is a silent "the integration just 401s" at run time.
+     */
+    key: v.pipe(v.string(), v.trim(), v.minLength(1), v.maxLength(128), v.regex(/^[A-Za-z_][A-Za-z0-9_]*$/, 'must be a valid environment variable name')),
+    /**
+     * How the integration expects the credential to be presented (`X-RD-Token: <value>`,
+     * `Authorization: Bearer <value>`). Folded into the brief verbatim: the agent writes the
+     * request itself, and a key with no stated header is a key it has to guess the use of.
+     */
+    usage: v.optional(v.pipe(v.string(), v.trim(), v.maxLength(400))),
+    /**
+     * When true (the default), an integration whose credential does not resolve is reported to
+     * the agent as UNAVAILABLE rather than offered. Set false only for an endpoint that genuinely
+     * works unauthenticated — an agent handed an API whose first call 401s burns a run
+     * discovering it.
+     */
+    required: v.optional(v.boolean()),
+});
+/**
+ * A generative binary integration a deployment registers in code.
+ *
+ * Shaped like a foundational service on purpose — identity, prose, and API contracts in the
+ * SAME `uploadApiContractSchema` vocabulary — so one contract renderer serves both and a
+ * deployment writes one kind of definition. What it adds is what a GENERATOR has and a shared
+ * service does not: the content types it produces, and the credential it needs.
+ */
+export const binaryGeneratorDefinitionSchema = v.object({
+    /** Stable id, referenced by a step's `stepOptions.binaryOutput.generatorIds`. */
+    id: slug,
+    name: v.pipe(v.string(), v.trim(), v.minLength(1), v.maxLength(200)),
+    /** One line, shown in the picker and the agent's brief. */
+    summary: v.pipe(v.string(), v.trim(), v.minLength(1), v.maxLength(400)),
+    /**
+     * What it is good at and what it is NOT for — style, resolution/length limits, cost profile.
+     * The half a model needs to pick between two registered generators of the same modality.
+     */
+    description: v.pipe(v.string(), v.trim(), v.maxLength(20_000)),
+    /**
+     * The content types it produces. At least one: a generator that produces nothing is not a
+     * generator, and an empty list would make it match every step's requirements by vacuity.
+     */
+    modalities: v.pipe(v.array(binaryModalitySchema), v.minLength(1)),
+    /**
+     * The concrete media types it can emit (`image/png`, `audio/mpeg`), when the integration
+     * pins them down. Absent ⇒ only the coarse {@link modalities} are known, which the brief
+     * states as such rather than implying every format of that modality is available.
+     */
+    mediaTypes: v.optional(v.array(mediaTypeSchema)),
+    /**
+     * The API's base URL. Stated to the agent so it does not have to infer one from the contract,
+     * and refused at registration unless it is `https` (or loopback) — the credential above rides
+     * this request.
+     */
+    endpoint: v.optional(v.pipe(v.string(), v.trim(), v.minLength(1), v.maxLength(2048))),
+    /**
+     * Operating notes folded into the agent's brief verbatim — polling an async job, the shape of
+     * a returned payload (base64 vs a signed URL), a rate limit worth respecting. This is where a
+     * deployment puts the knowledge that would otherwise be discovered once per run.
+     */
+    guidance: v.optional(v.pipe(v.string(), v.trim(), v.maxLength(20_000))),
+    credential: v.optional(binaryGeneratorCredentialSchema),
+    /**
+     * The integration's API contract documents, in the same formats the foundational catalog
+     * accepts. Injected as `.cat-context/` files beside the brief, so the agent calls the
+     * operations the contract declares instead of inventing them.
+     */
+    contracts: v.optional(v.array(uploadApiContractSchema)),
+});
+/**
+ * The ways `definition` fails {@link binaryGeneratorDefinitionSchema}, as readable lines — empty
+ * when it would be accepted.
+ *
+ * Exists for the same reason `foundationalServiceDefinitionIssues` does: the backend layers that
+ * hold a deployment's CODE-registered definitions to this shape (kernel, orchestration's boot
+ * validation) cannot depend on valibot, and re-stating the rules in a second place is how a
+ * registration ends up accepted where an equivalent one is refused.
+ */
+/**
+ * A registered integration as the WIRE carries it to the SPA (the workspace snapshot's
+ * `binaryGenerators`), so the pipeline builder can offer a step's `generatorIds` from the same
+ * set run admission validates against instead of asking a human to type an id.
+ *
+ * IDENTITY ONLY, and the omissions are the point. The credential's key NAME is left out — the
+ * picker has no use for it, and a workspace VIEWER has no business learning which environment
+ * variables the deployment sets. So are the contracts and the endpoint: they are the agent's
+ * interface to the integration, delivered as injected `.cat-context/` files at dispatch, and
+ * nothing a person picking from a list needs.
+ */
+export const registeredBinaryGeneratorSchema = v.object({
+    id: slug,
+    name: v.string(),
+    summary: v.string(),
+    /** What it produces — what the builder checks a step's declared content types against. */
+    modalities: v.array(binaryModalitySchema),
+    /** The concrete formats it pins down, when it declares any. Shown as detail, never a filter. */
+    mediaTypes: v.optional(v.array(mediaTypeSchema)),
+});
+export function binaryGeneratorDefinitionIssues(definition) {
+    const parsed = v.safeParse(binaryGeneratorDefinitionSchema, definition);
+    if (parsed.success)
+        return [];
+    return parsed.issues.map((issue) => {
+        const path = issue.path?.map((segment) => String(segment.key)).join('.');
+        return path ? `${path}: ${issue.message}` : issue.message;
+    });
+}
+//# sourceMappingURL=binary-generators.js.map

package/dist/binary-generators.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"binary-generators.js","sourceRoot":"","sources":["../src/binary-generators.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAC5B,OAAO,EAAE,oBAAoB,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAA;AAC9E,OAAO,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAA;AAEpE,8EAA8E;AAC9E,4FAA4F;AAC5F,uFAAuF;AACvF,6CAA6C;AAC7C,EAAE;AACF,+FAA+F;AAC/F,+FAA+F;AAC/F,8FAA8F;AAC9F,8FAA8F;AAC9F,8FAA8F;AAC9F,6FAA6F;AAC7F,+FAA+F;AAC/F,iCAAiC;AACjC,EAAE;AACF,+FAA+F;AAC/F,+FAA+F;AAC/F,uFAAuF;AACvF,2CAA2C;AAC3C,8EAA8E;AAE9E,MAAM,IAAI,GAAG,CAAC,CAAC,IAAI,CACjB,CAAC,CAAC,MAAM,EAAE,EACV,CAAC,CAAC,IAAI,EAAE,EACR,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EACd,CAAC,CAAC,SAAS,CAAC,EAAE,CAAC,EACf,CAAC,CAAC,KAAK,CAAC,sBAAsB,EAAE,4BAA4B,CAAC,CAC9D,CAAA;AAED;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,+BAA+B,GAAG,CAAC,CAAC,MAAM,CAAC;IACtD;;;;;OAKG;IACH,GAAG,EAAE,CAAC,CAAC,IAAI,CACT,CAAC,CAAC,MAAM,EAAE,EACV,CAAC,CAAC,IAAI,EAAE,EACR,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EACd,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,EAChB,CAAC,CAAC,KAAK,CAAC,0BAA0B,EAAE,2CAA2C,CAAC,CACjF;IACD;;;;OAIG;IACH,KAAK,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC;IACjE;;;;;OAKG;IACH,QAAQ,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC;CAClC,CAAC,CAAA;AAGF;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,+BAA+B,GAAG,CAAC,CAAC,MAAM,CAAC;IACtD,iFAAiF;IACjF,EAAE,EAAE,IAAI;IACR,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;IACpE,2DAA2D;IAC3D,OAAO,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;IACvE;;;OAGG;IACH,WAAW,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;IAC9D;;;OAGG;IACH,UAAU,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,oBAAoB,CAAC,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;IACjE;;;;OAIG;IACH,UAAU,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC;IAChD;;;;OAIG;IACH,QAAQ,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC;IACrF;;;;OAIG;IACH,QAAQ,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC;IACvE,UAAU,EAAE,CAAC,CAAC,QAAQ,CAAC,+BAA+B,CAAC;IACvD;;;;OAIG;IACH,SAAS,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,uBAAuB,CAAC,CAAC;CACxD,CAAC,CAAA;AAGF;;;;;;;;GAQG;AACH;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,+BAA+B,GAAG,CAAC,CAAC,MAAM,CAAC;IACtD,EAAE,EAAE,IAAI;IACR,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;IAChB,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;IACnB,0FAA0F;IAC1F,UAAU,EAAE,CAAC,CAAC,KAAK,CAAC,oBAAoB,CAAC;IACzC,gGAAgG;IAChG,UAAU,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC;CACjD,CAAC,CAAA;AAGF,MAAM,UAAU,+BAA+B,CAAC,UAAmB;IACjE,MAAM,MAAM,GAAG,CAAC,CAAC,SAAS,CAAC,+BAA+B,EAAE,UAAU,CAAC,CAAA;IACvE,IAAI,MAAM,CAAC,OAAO;QAAE,OAAO,EAAE,CAAA;IAC7B,OAAO,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;QACjC,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;QACxE,OAAO,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,KAAK,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAA;IAC3D,CAAC,CAAC,CAAA;AACJ,CAAC"}

package/dist/binary-modalities.d.ts

@@ -0,0 +1,36 @@
+import * as v from 'valibot';
+/**
+ * The CONTENT TYPE a generative integration produces, as a closed vocabulary.
+ *
+ * Closed, unlike the free-form capability tags on a foundational service, because this one is
+ * the platform's own: it decides which generator a step may be given for which deliverable, it
+ * groups the agent-facing brief, and the SPA renders a picker off it. A free-form tag would
+ * make `images` and `image` two different content types that look identical to a reader and
+ * silently fail to match — the exact failure `reservedCapabilityNearMiss` exists to catch for
+ * the tags that genuinely must stay free-form.
+ *
+ * The members are MODALITIES, not genres: music, speech and sound effects are all `audio`,
+ * because what differs between them is the prompt, while what differs between audio and video
+ * is the whole integration, its media types and what a step can do with the result. A
+ * deployment that must tell a music generator from a speech generator says so in the
+ * definition's `mediaTypes` and its description.
+ */
+export declare const binaryModalitySchema: v.PicklistSchema<["image", "audio", "video", "3d", "document"], undefined>;
+export type BinaryModality = v.InferOutput<typeof binaryModalitySchema>;
+/**
+ * The {@link BinaryModality} a media type belongs to, or `null` when nothing here recognises it.
+ *
+ * `null` is a REAL answer and callers must keep it apart from a modality: it means the platform
+ * does not know what this content is, which is different from knowing it is not an image. It is
+ * what lets a registration's declared media types be checked against its declared modalities
+ * (a generator claiming `audio` while listing `image/png` is a configuration error, not a
+ * judgement call) and what lets a settled step's declared artifacts be CLASSIFIED in code rather
+ * than by asking the model what kind of thing it just made.
+ */
+export declare function modalityOfMediaType(value: string): BinaryModality | null;
+/**
+ * A media type as `type/subtype` (parameters are NOT accepted — a generator declares what it
+ * produces, not how one request happened to be encoded).
+ */
+export declare const mediaTypeSchema: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.ToLowerCaseAction, v.MinLengthAction<string, 3, undefined>, v.MaxLengthAction<string, 128, undefined>, v.RegexAction<string, "must be a media type of the form type/subtype">]>;
+//# sourceMappingURL=binary-modalities.d.ts.map

package/dist/binary-modalities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binary-modalities.d.ts","sourceRoot":"","sources":["../src/binary-modalities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAY5B;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,oBAAoB,4EAW/B,CAAA;AACF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEvE;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI,CAoBxE;AAED;;;GAGG;AACH,eAAO,MAAM,eAAe,uPAU3B,CAAA"}

package/dist/binary-modalities.js

@@ -0,0 +1,83 @@
+import * as v from 'valibot';
+// ---------------------------------------------------------------------------
+// The CONTENT-TYPE vocabulary shared by the two halves of a binary-output step: what a registered
+// generative integration PRODUCES (`binary-generators.ts`) and what a step's stored artifacts
+// turned out to BE (`binary-outputs.ts`).
+//
+// Its own leaf module — no imports beyond valibot — because both of those modules need it and one
+// of them sits downstream of the entity schemas the other is reached through. A vocabulary this
+// small has no business creating an import cycle.
+// ---------------------------------------------------------------------------
+/**
+ * The CONTENT TYPE a generative integration produces, as a closed vocabulary.
+ *
+ * Closed, unlike the free-form capability tags on a foundational service, because this one is
+ * the platform's own: it decides which generator a step may be given for which deliverable, it
+ * groups the agent-facing brief, and the SPA renders a picker off it. A free-form tag would
+ * make `images` and `image` two different content types that look identical to a reader and
+ * silently fail to match — the exact failure `reservedCapabilityNearMiss` exists to catch for
+ * the tags that genuinely must stay free-form.
+ *
+ * The members are MODALITIES, not genres: music, speech and sound effects are all `audio`,
+ * because what differs between them is the prompt, while what differs between audio and video
+ * is the whole integration, its media types and what a step can do with the result. A
+ * deployment that must tell a music generator from a speech generator says so in the
+ * definition's `mediaTypes` and its description.
+ */
+export const binaryModalitySchema = v.picklist([
+    /** Still images — `image/png`, `image/webp`, `image/jpeg`, `image/svg+xml`. */
+    'image',
+    /** Anything heard: music, speech/voice-over, sound effects — `audio/mpeg`, `audio/wav`. */
+    'audio',
+    /** Moving pictures, with or without an audio track — `video/mp4`, `video/webm`. */
+    'video',
+    /** 3D geometry — `model/gltf-binary`, `model/obj`. */
+    '3d',
+    /** A rendered, paginated document — `application/pdf`. */
+    'document',
+]);
+/**
+ * The {@link BinaryModality} a media type belongs to, or `null` when nothing here recognises it.
+ *
+ * `null` is a REAL answer and callers must keep it apart from a modality: it means the platform
+ * does not know what this content is, which is different from knowing it is not an image. It is
+ * what lets a registration's declared media types be checked against its declared modalities
+ * (a generator claiming `audio` while listing `image/png` is a configuration error, not a
+ * judgement call) and what lets a settled step's declared artifacts be CLASSIFIED in code rather
+ * than by asking the model what kind of thing it just made.
+ */
+export function modalityOfMediaType(value) {
+    const type = value.trim().toLowerCase().split(';')[0]?.trim() ?? '';
+    const [top, subtype] = type.split('/');
+    if (!top || !subtype)
+        return null;
+    if (top === 'image')
+        return 'image';
+    if (top === 'audio')
+        return 'audio';
+    if (top === 'video')
+        return 'video';
+    if (top === 'model')
+        return '3d';
+    if (top === 'application') {
+        if (subtype === 'pdf')
+            return 'document';
+        // The 3D formats that predate `model/*` and are still what tooling emits: `sla` is STL, and
+        // `x-tgif` is what the shared mime database maps `.obj` to (an old collision with the TGIF
+        // drawing format, but it IS the type an OBJ file is served as, so recognising it is right).
+        // `octet-stream` stays null on purpose — it is the "no idea" type, and guessing `3d` from it
+        // would classify every unlabelled download as a model.
+        if (subtype === 'octet-stream')
+            return null;
+        if (['gltf+json', 'x-gltf', 'sla', 'x-tgif'].includes(subtype))
+            return '3d';
+        return null;
+    }
+    return null;
+}
+/**
+ * A media type as `type/subtype` (parameters are NOT accepted — a generator declares what it
+ * produces, not how one request happened to be encoded).
+ */
+export const mediaTypeSchema = v.pipe(v.string(), v.trim(), v.toLowerCase(), v.minLength(3), v.maxLength(128), v.regex(/^[a-z0-9][a-z0-9!#$&^_.+-]*\/[a-z0-9][a-z0-9!#$&^_.+-]*$/, 'must be a media type of the form type/subtype'));
+//# sourceMappingURL=binary-modalities.js.map

package/dist/binary-modalities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"binary-modalities.js","sourceRoot":"","sources":["../src/binary-modalities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,8EAA8E;AAC9E,kGAAkG;AAClG,8FAA8F;AAC9F,0CAA0C;AAC1C,EAAE;AACF,kGAAkG;AAClG,gGAAgG;AAChG,kDAAkD;AAClD,8EAA8E;AAE9E;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,CAAC,QAAQ,CAAC;IAC7C,+EAA+E;IAC/E,OAAO;IACP,2FAA2F;IAC3F,OAAO;IACP,mFAAmF;IACnF,OAAO;IACP,sDAAsD;IACtD,IAAI;IACJ,0DAA0D;IAC1D,UAAU;CACX,CAAC,CAAA;AAGF;;;;;;;;;GASG;AACH,MAAM,UAAU,mBAAmB,CAAC,KAAa;IAC/C,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,CAAA;IACnE,MAAM,CAAC,GAAG,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;IACtC,IAAI,CAAC,GAAG,IAAI,CAAC,OAAO;QAAE,OAAO,IAAI,CAAA;IACjC,IAAI,GAAG,KAAK,OAAO;QAAE,OAAO,OAAO,CAAA;IACnC,IAAI,GAAG,KAAK,OAAO;QAAE,OAAO,OAAO,CAAA;IACnC,IAAI,GAAG,KAAK,OAAO;QAAE,OAAO,OAAO,CAAA;IACnC,IAAI,GAAG,KAAK,OAAO;QAAE,OAAO,IAAI,CAAA;IAChC,IAAI,GAAG,KAAK,aAAa,EAAE,CAAC;QAC1B,IAAI,OAAO,KAAK,KAAK;YAAE,OAAO,UAAU,CAAA;QACxC,4FAA4F;QAC5F,2FAA2F;QAC3F,4FAA4F;QAC5F,6FAA6F;QAC7F,uDAAuD;QACvD,IAAI,OAAO,KAAK,cAAc;YAAE,OAAO,IAAI,CAAA;QAC3C,IAAI,CAAC,WAAW,EAAE,QAAQ,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC;YAAE,OAAO,IAAI,CAAA;QAC3E,OAAO,IAAI,CAAA;IACb,CAAC;IACD,OAAO,IAAI,CAAA;AACb,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,CAAC,IAAI,CACnC,CAAC,CAAC,MAAM,EAAE,EACV,CAAC,CAAC,IAAI,EAAE,EACR,CAAC,CAAC,WAAW,EAAE,EACf,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EACd,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,EAChB,CAAC,CAAC,KAAK,CACL,0DAA0D,EAC1D,+CAA+C,CAChD,CACF,CAAA"}

package/dist/binary-outputs.d.ts

@@ -21,6 +21,29 @@ export declare const binaryOutputConfigSchema: v.ObjectSchema<{
      * context files are the whole scope.
      */
     readonly contextServiceIds: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 64, undefined>, v.RegexAction<string, "must be a lower-kebab slug">]>, undefined>, undefined>;
+    /**
+     * The GENERATIVE INTEGRATIONS this step may call to produce its artifacts — ids from the
+     * deployment's code-registered `BinaryGeneratorRegistry` (see `binary-generators.ts`).
+     *
+     * A separate half of the selection from the two above, because it answers a different
+     * question: those say where an artifact GOES, this says what MAKES it. Absent ⇒ the step
+     * generates through whatever its agent already has (a model with native image output, a tool
+     * server), and its brief says so rather than naming an integration it does not have.
+     * Validated at run admission against the registry, never against a saved copy.
+     */
+    readonly generatorIds: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 64, undefined>, v.RegexAction<string, "must be a lower-kebab slug">]>, undefined>, undefined>;
+    /**
+     * The CONTENT TYPES this step is expected to deliver. Every one of them must be covered by a
+     * selected generator, or the run is refused at admission — a step that must produce a theme
+     * song and selected only an image generator cannot do its job, and the failure would
+     * otherwise surface as an agent apologising at the end of a paid run.
+     *
+     * Absent ⇒ no requirement is imposed and the selected generators' own modalities are the
+     * whole story. It is deliberately NOT defaulted from the selection: "this step must produce
+     * audio" is a statement about the WORK, and deriving it from the current selection would make
+     * removing the audio generator look like a change of requirements rather than a break.
+     */
+    readonly modalities: v.OptionalSchema<v.ArraySchema<v.PicklistSchema<["image", "audio", "video", "3d", "document"], undefined>, undefined>, undefined>;
 }, undefined>;
 export type BinaryOutputConfig = v.InferOutput<typeof binaryOutputConfigSchema>;
 /** One stored artifact a binary-generating step declared in its reply's machine-read block. */
@@ -43,6 +66,21 @@ export declare const binaryOutputArtifactSchema: v.ObjectSchema<{
     readonly contentType: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
     /** A one-line description of what was generated. */
     readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    /**
+     * The generative integration the agent says PRODUCED the artifact, lowercased on read-back
+     * like {@link service}. Optional because a step may generate without a registered integration
+     * (a model with native image output), and a claim of "no generator" is a different fact from
+     * a claim naming one the deployment does not register — which is why an unrecognised id is
+     * NAMED in the report rather than dropped.
+     */
+    readonly generator: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    /**
+     * The CONTENT TYPE of the artifact, DERIVED in code from {@link contentType} — never read off
+     * the model's prose. Absent when no media type was declared, or when the declared one is not
+     * one the platform recognises: "we do not know what this is" and "this is not an image" are
+     * different answers, and only the second could justify a warning.
+     */
+    readonly modality: v.OptionalSchema<v.PicklistSchema<["image", "audio", "video", "3d", "document"], undefined>, undefined>;
 }, undefined>;
 export type BinaryOutputArtifact = v.InferOutput<typeof binaryOutputArtifactSchema>;
 /**
@@ -80,9 +118,42 @@ export declare const binaryOutputReportSchema: v.ObjectSchema<{
         readonly contentType: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
         /** A one-line description of what was generated. */
         readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        /**
+         * The generative integration the agent says PRODUCED the artifact, lowercased on read-back
+         * like {@link service}. Optional because a step may generate without a registered integration
+         * (a model with native image output), and a claim of "no generator" is a different fact from
+         * a claim naming one the deployment does not register — which is why an unrecognised id is
+         * NAMED in the report rather than dropped.
+         */
+        readonly generator: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        /**
+         * The CONTENT TYPE of the artifact, DERIVED in code from {@link contentType} — never read off
+         * the model's prose. Absent when no media type was declared, or when the declared one is not
+         * one the platform recognises: "we do not know what this is" and "this is not an image" are
+         * different answers, and only the second could justify a warning.
+         */
+        readonly modality: v.OptionalSchema<v.PicklistSchema<["image", "audio", "video", "3d", "document"], undefined>, undefined>;
     }, undefined>, undefined>;
     /** Distinct `service` ids named in entries that the resolved catalog does not contain. */
     readonly unknownServices: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+    /**
+     * Distinct `generator` ids named in entries that the deployment does not register. Kept apart
+     * from {@link unknownServices} because they resolve against different registries and need
+     * different fixes — a storage id points at the workspace's foundational catalog, a generator
+     * id at the deployment's code. Entries are RETAINED either way: the platform records what the
+     * agent claimed and a reader judges it.
+     */
+    readonly unknownGenerators: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+    /**
+     * Set when the deployment's registered integrations could not be READ at settlement, so no
+     * claimed `generator` id could be checked against them (a mothership-mode node whose mothership
+     * was unreachable). Its own field rather than an empty {@link unknownGenerators}, for the
+     * reason that runs through this whole feature: "every id checked out" and "nothing could be
+     * checked" are the same value and opposite facts, and only one of them is evidence. The
+     * artifacts themselves — and the STORAGE half's verdict, which resolves against a different
+     * catalog and is unaffected — are recorded either way, because what could be derived must be.
+     */
+    readonly generatorsUnverified: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
     /** Entries dropped because they were not an object with `service` + `location` strings. */
     readonly invalidEntries: v.NumberSchema<undefined>;
     /** Valid entries dropped past the per-report cap. */

package/dist/binary-outputs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"binary-outputs.d.ts","sourceRoot":"","sources":["../src/binary-outputs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAkB5B;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB;IACnC;;;;OAIG;;IAEH;;;;;;OAMG;;aAEH,CAAA;AACF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAE/E,+FAA+F;AAC/F,eAAO,MAAM,0BAA0B;IACrC;;;;;OAKG;;IAEH;;;OAGG;;IAEH,8FAA8F;;IAE9F,uEAAuE;;IAEvE,oDAAoD;;aAEpD,CAAA;AACF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAEnF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,wBAAwB;;QApCnC;;;;;WAKG;;QAEH;;;WAGG;;QAEH,8FAA8F;;QAE9F,uEAAuE;;QAEvE,oDAAoD;;;IAsBpD,0FAA0F;;IAE1F,2FAA2F;;IAE3F,qDAAqD;;IAErD,0FAA0F;;IAE1F,qEAAqE;;aAErE,CAAA;AACF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,wBAAwB,CAAC,CAAA"}
+{"version":3,"file":"binary-outputs.d.ts","sourceRoot":"","sources":["../src/binary-outputs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAmB5B;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB;IACnC;;;;OAIG;;IAEH;;;;;;OAMG;;IAEH;;;;;;;;;OASG;;IAEH;;;;;;;;;;OAUG;;aAEH,CAAA;AACF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAE/E,+FAA+F;AAC/F,eAAO,MAAM,0BAA0B;IACrC;;;;;OAKG;;IAEH;;;OAGG;;IAEH,8FAA8F;;IAE9F,uEAAuE;;IAEvE,oDAAoD;;IAEpD;;;;;;OAMG;;IAEH;;;;;OAKG;;aAEH,CAAA;AACF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAEnF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,wBAAwB;;QAnDnC;;;;;WAKG;;QAEH;;;WAGG;;QAEH,8FAA8F;;QAE9F,uEAAuE;;QAEvE,oDAAoD;;QAEpD;;;;;;WAMG;;QAEH;;;;;WAKG;;;IAsBH,0FAA0F;;IAE1F;;;;;;OAMG;;IAEH;;;;;;;;OAQG;;IAEH,2FAA2F;;IAE3F,qDAAqD;;IAErD,0FAA0F;;IAE1F,qEAAqE;;aAErE,CAAA;AACF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,wBAAwB,CAAC,CAAA"}

package/dist/binary-outputs.js

@@ -1,4 +1,5 @@
 import * as v from 'valibot';
+import { binaryModalitySchema } from './binary-modalities.js';
 // Wire vocabulary for BINARY-OUTPUT agent steps (docs/initiatives/binary-output-foundational-storage.md):
 // a step whose kind GENERATES binary artifacts (image generation is the canonical example) and
 // stores them through a FOUNDATIONAL SERVICE the step selected from the workspace's catalog —
@@ -29,6 +30,29 @@ export const binaryOutputConfigSchema = v.object({
      * context files are the whole scope.
      */
     contextServiceIds: v.optional(v.array(serviceId)),
+    /**
+     * The GENERATIVE INTEGRATIONS this step may call to produce its artifacts — ids from the
+     * deployment's code-registered `BinaryGeneratorRegistry` (see `binary-generators.ts`).
+     *
+     * A separate half of the selection from the two above, because it answers a different
+     * question: those say where an artifact GOES, this says what MAKES it. Absent ⇒ the step
+     * generates through whatever its agent already has (a model with native image output, a tool
+     * server), and its brief says so rather than naming an integration it does not have.
+     * Validated at run admission against the registry, never against a saved copy.
+     */
+    generatorIds: v.optional(v.array(serviceId)),
+    /**
+     * The CONTENT TYPES this step is expected to deliver. Every one of them must be covered by a
+     * selected generator, or the run is refused at admission — a step that must produce a theme
+     * song and selected only an image generator cannot do its job, and the failure would
+     * otherwise surface as an agent apologising at the end of a paid run.
+     *
+     * Absent ⇒ no requirement is imposed and the selected generators' own modalities are the
+     * whole story. It is deliberately NOT defaulted from the selection: "this step must produce
+     * audio" is a statement about the WORK, and deriving it from the current selection would make
+     * removing the audio generator look like a change of requirements rather than a break.
+     */
+    modalities: v.optional(v.array(binaryModalitySchema)),
 });
 /** One stored artifact a binary-generating step declared in its reply's machine-read block. */
 export const binaryOutputArtifactSchema = v.object({
@@ -50,6 +74,21 @@ export const binaryOutputArtifactSchema = v.object({
     contentType: v.optional(v.string()),
     /** A one-line description of what was generated. */
     description: v.optional(v.string()),
+    /**
+     * The generative integration the agent says PRODUCED the artifact, lowercased on read-back
+     * like {@link service}. Optional because a step may generate without a registered integration
+     * (a model with native image output), and a claim of "no generator" is a different fact from
+     * a claim naming one the deployment does not register — which is why an unrecognised id is
+     * NAMED in the report rather than dropped.
+     */
+    generator: v.optional(v.string()),
+    /**
+     * The CONTENT TYPE of the artifact, DERIVED in code from {@link contentType} — never read off
+     * the model's prose. Absent when no media type was declared, or when the declared one is not
+     * one the platform recognises: "we do not know what this is" and "this is not an image" are
+     * different answers, and only the second could justify a warning.
+     */
+    modality: v.optional(binaryModalitySchema),
 });
 /**
  * What a settled binary-generating step DECLARED it stored, read back from the fenced
@@ -70,6 +109,24 @@ export const binaryOutputReportSchema = v.object({
     stored: v.array(binaryOutputArtifactSchema),
     /** Distinct `service` ids named in entries that the resolved catalog does not contain. */
     unknownServices: v.array(v.string()),
+    /**
+     * Distinct `generator` ids named in entries that the deployment does not register. Kept apart
+     * from {@link unknownServices} because they resolve against different registries and need
+     * different fixes — a storage id points at the workspace's foundational catalog, a generator
+     * id at the deployment's code. Entries are RETAINED either way: the platform records what the
+     * agent claimed and a reader judges it.
+     */
+    unknownGenerators: v.array(v.string()),
+    /**
+     * Set when the deployment's registered integrations could not be READ at settlement, so no
+     * claimed `generator` id could be checked against them (a mothership-mode node whose mothership
+     * was unreachable). Its own field rather than an empty {@link unknownGenerators}, for the
+     * reason that runs through this whole feature: "every id checked out" and "nothing could be
+     * checked" are the same value and opposite facts, and only one of them is evidence. The
+     * artifacts themselves — and the STORAGE half's verdict, which resolves against a different
+     * catalog and is unaffected — are recorded either way, because what could be derived must be.
+     */
+    generatorsUnverified: v.optional(v.literal(true)),
     /** Entries dropped because they were not an object with `service` + `location` strings. */
     invalidEntries: v.number(),
     /** Valid entries dropped past the per-report cap. */

package/dist/binary-outputs.js.map

@@ -1 +1 @@
-{"version":3,"file":"binary-outputs.js","sourceRoot":"","sources":["../src/binary-outputs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,0GAA0G;AAC1G,+FAA+F;AAC/F,8FAA8F;AAC9F,+FAA+F;AAC/F,gGAAgG;AAChG,gGAAgG;AAChG,6EAA6E;AAE7E,MAAM,SAAS,GAAG,CAAC,CAAC,IAAI,CACtB,CAAC,CAAC,MAAM,EAAE,EACV,CAAC,CAAC,IAAI,EAAE,EACR,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EACd,CAAC,CAAC,SAAS,CAAC,EAAE,CAAC,EACf,CAAC,CAAC,KAAK,CAAC,sBAAsB,EAAE,4BAA4B,CAAC,CAC9D,CAAA;AAED;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC/C;;;;OAIG;IACH,gBAAgB,EAAE,SAAS;IAC3B;;;;;;OAMG;IACH,iBAAiB,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;CAClD,CAAC,CAAA;AAGF,+FAA+F;AAC/F,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC,CAAC,MAAM,CAAC;IACjD;;;;;OAKG;IACH,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;IACnB;;;OAGG;IACH,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE;IACpB,8FAA8F;IAC9F,MAAM,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;IAC9B,uEAAuE;IACvE,WAAW,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;IACnC,oDAAoD;IACpD,WAAW,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;CACpC,CAAC,CAAA;AAGF;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC/C,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,0BAA0B,CAAC;IAC3C,0FAA0F;IAC1F,eAAe,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;IACpC,2FAA2F;IAC3F,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE;IAC1B,qDAAqD;IACrD,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;IACnB,0FAA0F;IAC1F,WAAW,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC;IACpC,qEAAqE;IACrE,UAAU,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC;CACpC,CAAC,CAAA"}
+{"version":3,"file":"binary-outputs.js","sourceRoot":"","sources":["../src/binary-outputs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAC5B,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAA;AAE7D,0GAA0G;AAC1G,+FAA+F;AAC/F,8FAA8F;AAC9F,+FAA+F;AAC/F,gGAAgG;AAChG,gGAAgG;AAChG,6EAA6E;AAE7E,MAAM,SAAS,GAAG,CAAC,CAAC,IAAI,CACtB,CAAC,CAAC,MAAM,EAAE,EACV,CAAC,CAAC,IAAI,EAAE,EACR,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EACd,CAAC,CAAC,SAAS,CAAC,EAAE,CAAC,EACf,CAAC,CAAC,KAAK,CAAC,sBAAsB,EAAE,4BAA4B,CAAC,CAC9D,CAAA;AAED;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC/C;;;;OAIG;IACH,gBAAgB,EAAE,SAAS;IAC3B;;;;;;OAMG;IACH,iBAAiB,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;IACjD;;;;;;;;;OASG;IACH,YAAY,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;IAC5C;;;;;;;;;;OAUG;IACH,UAAU,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,oBAAoB,CAAC,CAAC;CACtD,CAAC,CAAA;AAGF,+FAA+F;AAC/F,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC,CAAC,MAAM,CAAC;IACjD;;;;;OAKG;IACH,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;IACnB;;;OAGG;IACH,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE;IACpB,8FAA8F;IAC9F,MAAM,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;IAC9B,uEAAuE;IACvE,WAAW,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;IACnC,oDAAoD;IACpD,WAAW,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;IACnC;;;;;;OAMG;IACH,SAAS,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;IACjC;;;;;OAKG;IACH,QAAQ,EAAE,CAAC,CAAC,QAAQ,CAAC,oBAAoB,CAAC;CAC3C,CAAC,CAAA;AAGF;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC/C,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,0BAA0B,CAAC;IAC3C,0FAA0F;IAC1F,eAAe,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;IACpC;;;;;;OAMG;IACH,iBAAiB,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;IACtC;;;;;;;;OAQG;IACH,oBAAoB,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IACjD,2FAA2F;IAC3F,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE;IAC1B,qDAAqD;IACrD,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;IACnB,0FAA0F;IAC1F,WAAW,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC;IACpC,qEAAqE;IACrE,UAAU,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC;CACpC,CAAC,CAAA"}