@arnilo/prism 0.3.2 → 0.5.0

package/dist/cli-runner.js

@@ -1,7 +1,8 @@
 import { readFile } from "node:fs/promises";
 import { basename, dirname } from "node:path";
 import process from "node:process";
-import { initUsage, runInitCommand } from "./cli-init.js";
+import { runPrismDevSubcommand } from "./cli-dev.js";
+import { initUsage, loadProvidersCatalog, runInitCommand } from "./cli-init.js";
 import { providerAddUsage, runProviderAddCommand } from "./cli-provider-add.js";
 import { createContributionRegistries, registerDiscoveredContributions } from "./contributions.js";
 import { createAgent, createContributionRegistry, createMockProvider, providerDone, providerTextDelta, resolveInstructionInjectors, } from "./index.js";
@@ -13,12 +14,16 @@ import { createPathTrustPolicy } from "./node/trust.js";
 import { runRpcServer } from "./rpc.js";
 import { createSkillRegistry } from "./skills.js";
 export const usage = `Usage: prism [--mode print|json|rpc] [-p prompt] [options]
-       prism init <dir> [--provider <name>] [--with-workflows] [--with-evals] [--force]
+       prism init <dir> [--template <name>] [--list-templates] [--provider <name>] [--with-workflows] [--with-evals] [--force]
        prism providers add <name> [--base-url <url>] [--env-key <name>] [--model <id>] [--force]
+       prism dev [--port <n>] [--host <addr>]   (loopback inspector; delegates into @arnilo/prism-dev)
+
 
 Options:
   -p, --prompt <text>        Prompt to run in print/json mode
-  --provider <name>          Explicit provider id (mock is built in for smoke tests)
+  --provider <name>          Provider id from the init provider catalog ('mock' is built in;
+                             real providers need their @arnilo/prism-providers package +
+                             credential env var)
   --model <name>             Explicit model name
   --session <id>             Session id
   --system <text>            System instructions
@@ -201,11 +206,19 @@ function parseKinds(csv, flag) {
     return kinds;
 }
 export async function runCli(argv, runtime) {
+    if (argv[0] === "dev") {
+        return runPrismDevSubcommand(argv.slice(1), {
+            stdout: runtime.stdout,
+            stderr: runtime.stderr,
+            ...(runtime.loadDevCli ? { loadDevCli: runtime.loadDevCli } : {}),
+        });
+    }
     if (argv[0] === "init") {
         const initRuntime = {
             stdout: runtime.stdout,
             stderr: runtime.stderr,
             ...(runtime.initTemplatesRoot !== undefined ? { templatesRoot: runtime.initTemplatesRoot } : {}),
+            ...(runtime.initGalleryRoot !== undefined ? { galleryRoot: runtime.initGalleryRoot } : {}),
             ...(runtime.initPackageVersion !== undefined ? { packageVersion: runtime.initPackageVersion } : {}),
             ...(runtime.cwd !== undefined ? { cwd: runtime.cwd } : {}),
         };
@@ -304,7 +317,7 @@ export async function runCli(argv, runtime) {
             });
             options = { ...options, systemPromptLayers: layers };
         }
-        const session = (runtime.createSession ?? defaultCreateSession)(options);
+        const session = await (runtime.createSession ?? defaultCreateSession)(options);
         await runPromptMode(session, options, runtime.stdout, mode);
         return 0;
     }
@@ -335,13 +348,47 @@ export async function runPromptMode(session, options, stdout, mode) {
 }
 export class CliUsageError extends Error {
 }
-function defaultCreateSession(options) {
-    if (options.provider !== "mock")
-        throw new CliUsageError("No provider configured. Pass --provider mock for a smoke test or embed Prism with an explicit provider.");
-    const model = { provider: "mock", model: options.model ?? "mock" };
+/** Build the agent session for the CLI. Real providers resolve through the init
+ *  provider catalog (`templates/init/providers.json`): the catalog names the
+ *  factory module/export and credential env var, the CLI imports it from the
+ *  consumer's node_modules — same catalog `prism init` scaffolds from, so the
+ *  CLI and the scaffold never disagree about how a provider is built. */
+async function defaultCreateSession(options) {
+    const providerId = options.provider;
+    if (!providerId) {
+        throw new CliUsageError("No provider configured. Pass --provider <id> (see the init provider catalog, or 'mock') or embed Prism with an explicit provider.");
+    }
+    if (providerId === "mock")
+        return mockSession(options);
+    const spec = loadProvidersCatalog().get(providerId);
+    if (!spec?.factoryModule || !spec.factoryExport) {
+        throw new CliUsageError(`Unknown provider "${providerId}". Supported: ${["mock", ...loadProvidersCatalog().keys()].join(", ")} — or embed Prism with an explicit provider.`);
+    }
+    const envKey = spec.envKey ?? "";
+    if (!process.env[envKey])
+        throw new CliUsageError(`Provider "${providerId}" requires ${envKey} in the environment.`);
+    let factory;
+    try {
+        factory = (await import(spec.factoryModule))[spec.factoryExport];
+    }
+    catch {
+        throw new CliUsageError(`Provider "${providerId}" needs the ${spec.packageName} package installed (import ${spec.factoryModule} failed).`);
+    }
+    if (typeof factory !== "function") {
+        throw new CliUsageError(`Provider "${providerId}": ${spec.factoryModule} does not export ${spec.factoryExport}.`);
+    }
+    const providerInstance = factory({ apiKey: () => process.env[envKey] });
+    const modelConfig = { provider: spec.modelProvider, model: options.model ?? spec.modelName };
+    return agentSession({ ...options, providerInstance, modelConfig });
+}
+function mockSession(options) {
+    const modelConfig = { provider: "mock", model: options.model ?? "mock" };
+    return agentSession({ ...options, providerInstance: createMockProvider([providerTextDelta("Hello"), providerDone()]), modelConfig });
+}
+function agentSession(options) {
     return createAgent({
-        model,
-        provider: createMockProvider([providerTextDelta("Hello"), providerDone()]),
+        model: options.modelConfig,
+        provider: options.providerInstance,
         instructions: options.system,
         // ponytail: Phase 31 — file layers compose with `instructions` (base) via the existing
         // composeSystemPrompt pipeline; rank order (user<package<app<run) is enforced inside.

package/dist/content.d.ts

@@ -1,6 +1,6 @@
-import type { ContentBlock, ImageContent, Message, ModelConfig, ResourceLoadContext, ResourceLoader } from "./contracts.js";
+import type { ContentBlock, ImageContent, Message, ModelConfig, ResourceLoadContext, ResourceLoader, VideoContent } from "./contracts.js";
 /** Known model input capability tags for `ModelCapabilities.input`. */
-export declare const MODEL_INPUT_CAPABILITIES: readonly ["text", "image", "audio", "file", "document"];
+export declare const MODEL_INPUT_CAPABILITIES: readonly ["text", "image", "audio", "file", "document", "video"];
 export type ModelInputCapability = (typeof MODEL_INPUT_CAPABILITIES)[number];
 /** Default per-item media byte ceiling (10 MB; aligns with coding-agent image bounds). */
 export declare const DEFAULT_MAX_MEDIA_ITEM_BYTES = 10000000;
@@ -45,7 +45,7 @@ export interface DocumentContent {
     readonly transcript?: string;
     readonly metadata?: Readonly<Record<string, unknown>>;
 }
-export type MediaContentBlock = AudioContent | FileContent | DocumentContent | ImageContent;
+export type MediaContentBlock = AudioContent | FileContent | DocumentContent | ImageContent | VideoContent;
 export interface MediaContentBounds {
     readonly maxItemBytes?: number;
     readonly maxRequestBytes?: number;

package/dist/content.js

@@ -3,7 +3,7 @@ import { isIP } from "node:net";
 import { pinnedFetch } from "./pinned-fetch.js";
 import { assertPermission } from "./security.js";
 /** Known model input capability tags for `ModelCapabilities.input`. */
-export const MODEL_INPUT_CAPABILITIES = ["text", "image", "audio", "file", "document"];
+export const MODEL_INPUT_CAPABILITIES = ["text", "image", "audio", "file", "document", "video"];
 /** Default per-item media byte ceiling (10 MB; aligns with coding-agent image bounds). */
 export const DEFAULT_MAX_MEDIA_ITEM_BYTES = 10_000_000;
 /** Default total media byte budget per request assembly. */
@@ -44,6 +44,8 @@ export function contentBlockInputModality(block) {
             return "file";
         case "document":
             return "document";
+        case "video":
+            return "video";
         default:
             return undefined;
     }

package/dist/contracts-core/agent.d.ts

@@ -59,6 +59,9 @@ export interface AgentConfig {
     readonly activateAllSkills?: true;
     /** Progressive: catalog (name+description) unless loaded; eager: full instructions every turn. Default progressive. */
     readonly skillsDisclosure?: import("../skill-disclosure.js").SkillsDisclosure;
+    /** Tools disclosure: "all" (default) sends every active tool schema; "search" sends top-k + the generated `search_tools` tool. */
+    readonly toolsDisclosure?: import("../tool-search.js").ToolsDisclosure;
+    readonly toolsSearch?: import("../tool-search.js").ToolsSearchOptions;
     /** Opt-in projection-only fold for aged large tool results in provider view; store untouched. */
     readonly toolResultFold?: import("../tool-result-fold.js").ToolResultFoldOptions;
     readonly inputBuilder?: InputBuilder;
@@ -74,6 +77,8 @@ export interface AgentConfig {
     readonly systemPrompt?: SystemPromptConfig;
     readonly redactor?: SecretRedactor;
     readonly runLedger?: RunLedger;
+    /** Optional host-supplied pricing adapter: turn usage without a provider-reported cost is priced through it; absent or stale quotes degrade to usage-only. */
+    readonly costCatalog?: import("./content.js").CostCatalog;
     /** Optional durable recovery store. */
     readonly effectStore?: ToolEffectStore;
     readonly ownership?: OwnershipScope;
@@ -252,6 +257,9 @@ export interface PromptBuildRequest {
     readonly skills?: readonly Skill[];
     readonly skillsDisclosure?: import("../skill-disclosure.js").SkillsDisclosure;
     readonly loadedSkills?: import("../skill-disclosure.js").LoadedSkillSet;
+    /** Tools disclosure: "all" (default) sends every active tool schema; "search" sends top-k + the generated `search_tools` tool. */
+    readonly toolsDisclosure?: import("../tool-search.js").ToolsDisclosure;
+    readonly toolsSearch?: import("../tool-search.js").ToolsSearchOptions;
     /** Skills demoted to catalog-only by context budget this turn. */
     readonly demotedSkillBodies?: readonly string[];
     readonly tools?: readonly ToolDefinition[];

package/dist/contracts-core/batch.d.ts

@@ -0,0 +1,97 @@
+/** Provider-neutral async batch-jobs contract (plan 061 Task 7).
+ *
+ * Standalone contract — deliberately not coupled to the orchestration saga seam
+ * in v1 (plan decision). Job ids are opaque strings; request payloads are
+ * provider-native `JsonObject` bodies and inherit the provider's request caps;
+ * polling is a plain exported utility (`pollBatch`), never loop-integrated into
+ * core.
+ */
+import type { JsonObject, ModelCapabilities, ModelConfig } from "./content.js";
+/** Neutral job state union. Adapters map provider states onto these:
+ *  `queued` (submitted, not yet running), `cancelling`, and the three terminal
+ *  states `completed` / `failed` / `cancelled` / `expired`. */
+export type BatchJobState = "queued" | "running" | "cancelling" | "completed" | "failed" | "cancelled" | "expired";
+export declare const BATCH_TERMINAL_STATES: readonly BatchJobState[];
+export declare function isBatchJobTerminal(job: Pick<BatchJob, "state">): boolean;
+export type BatchJobsErrorCode = "empty_requests" | "too_many_requests" | "unsupported_model" | "job_not_found" | "invalid_cursor" | "request_failed" | "response_malformed" | "unsupported_operation" | "job_failed" | "job_cancelled" | "job_expired";
+export declare class BatchJobsError extends Error {
+    readonly code: BatchJobsErrorCode;
+    constructor(code: BatchJobsErrorCode, message: string);
+}
+export declare function modelSupportsBatchJobs(capabilities?: ModelCapabilities): boolean;
+export declare function assertBatchJobsSupported(model: ModelConfig): void;
+/** One batched request: provider-native body plus an optional caller-assigned
+ *  correlation id echoed on results. Bodies are opaque to the contract. */
+export interface BatchRequestItem {
+    readonly customId?: string;
+    readonly body: JsonObject;
+}
+export interface BatchSubmitRequest {
+    readonly model: string;
+    readonly requests: readonly BatchRequestItem[];
+    /** Provider-native routing metadata (weights, priorities) — opaque passthrough. */
+    readonly metadata?: JsonObject;
+    readonly signal?: AbortSignal;
+}
+export interface BatchJob {
+    /** Opaque provider job id — contract never parses or scopes it. */
+    readonly id: string;
+    readonly state: BatchJobState;
+    readonly requestCounts?: {
+        readonly total: number;
+        readonly completed: number;
+        readonly failed: number;
+    };
+    readonly createdAt?: string;
+    readonly completedAt?: string;
+    readonly expiresAt?: string;
+    /** Provider-native job fields, unmodified, for host-side audits. */
+    readonly raw?: JsonObject;
+    /** Terminal failure detail when `state` is `failed`. */
+    readonly error?: {
+        readonly code?: string;
+        readonly message?: string;
+    };
+}
+export interface BatchResultItem {
+    readonly customId: string;
+    /** Provider-native per-request response (status + payload), when it succeeded. */
+    readonly response?: JsonObject;
+    /** Per-request failure detail (the job itself may still be `completed`). */
+    readonly error?: {
+        readonly code?: string;
+        readonly message?: string;
+    };
+    /** Provider-native raw line for audits. */
+    readonly raw?: JsonObject;
+}
+export interface BatchResultsPage {
+    readonly job?: BatchJob;
+    readonly items: readonly BatchResultItem[];
+    /** Opaque continuation token; `null`/`undefined` when the page is last. */
+    readonly nextCursor?: string | null;
+}
+export interface BatchResultsOptions {
+    readonly cursor?: string | null;
+    readonly pageSize?: number;
+    readonly signal?: AbortSignal;
+}
+export interface BatchJobsProvider {
+    readonly id: string;
+    submit(request: BatchSubmitRequest): Promise<BatchJob>;
+    status(jobId: string): Promise<BatchJob>;
+    cancel(jobId: string): Promise<BatchJob>;
+    results(jobId: string, options?: BatchResultsOptions): Promise<BatchResultsPage>;
+}
+export interface PollBatchOptions {
+    readonly intervalMs?: number;
+    /** Backoff multiplier applied per poll; caps at `maxIntervalMs`. */
+    readonly backoffMultiplier?: number;
+    readonly maxIntervalMs?: number;
+    readonly maxAttempts?: number;
+    readonly signal?: AbortSignal;
+}
+/** Poll a job until it reaches a terminal state. Plain utility — core never
+ *  calls it. Terminal failure states surface typed `BatchJobsError`s
+ *  (`job_failed` / `job_cancelled` / `job_expired`); only `completed` resolves. */
+export declare function pollBatch(provider: BatchJobsProvider, jobId: string, options?: PollBatchOptions): Promise<BatchJob>;

package/dist/contracts-core/batch.js

@@ -0,0 +1,65 @@
+export const BATCH_TERMINAL_STATES = ["completed", "failed", "cancelled", "expired"];
+export function isBatchJobTerminal(job) {
+    return BATCH_TERMINAL_STATES.includes(job.state);
+}
+export class BatchJobsError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = "BatchJobsError";
+        this.code = code;
+    }
+}
+export function modelSupportsBatchJobs(capabilities) {
+    return capabilities?.batchJobs === true;
+}
+export function assertBatchJobsSupported(model) {
+    if (!modelSupportsBatchJobs(model.capabilities)) {
+        throw new BatchJobsError("unsupported_model", `Model ${model.provider}/${model.model} does not declare the batchJobs capability`);
+    }
+}
+/** Poll a job until it reaches a terminal state. Plain utility — core never
+ *  calls it. Terminal failure states surface typed `BatchJobsError`s
+ *  (`job_failed` / `job_cancelled` / `job_expired`); only `completed` resolves. */
+export async function pollBatch(provider, jobId, options = {}) {
+    const intervalMs = options.intervalMs ?? 30_000;
+    const multiplier = options.backoffMultiplier ?? 1;
+    const maxIntervalMs = options.maxIntervalMs ?? intervalMs * 16;
+    const maxAttempts = options.maxAttempts ?? Number.POSITIVE_INFINITY;
+    let delay = intervalMs;
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+        if (options.signal?.aborted)
+            throw options.signal.reason ?? new Error("pollBatch aborted");
+        let job;
+        try {
+            job = await provider.status(jobId);
+        }
+        catch (error) {
+            if (error instanceof BatchJobsError && error.code === "job_not_found") {
+                throw new BatchJobsError("job_not_found", `pollBatch: job ${jobId} not found`);
+            }
+            throw error;
+        }
+        if (isBatchJobTerminal(job)) {
+            if (job.state === "completed")
+                return job;
+            if (job.state === "cancelled")
+                throw new BatchJobsError("job_cancelled", `Batch job ${jobId} was cancelled`);
+            if (job.state === "expired")
+                throw new BatchJobsError("job_expired", `Batch job ${jobId} expired before completion`);
+            throw new BatchJobsError("job_failed", `Batch job ${jobId} failed: ${job.error?.message ?? "provider reported failure"}`);
+        }
+        if (attempt === maxAttempts)
+            break;
+        await new Promise((resolve) => {
+            const timer = setTimeout(resolve, delay);
+            options.signal?.addEventListener("abort", () => {
+                clearTimeout(timer);
+                resolve();
+            }, { once: true });
+        });
+        delay = Math.min(delay * multiplier, maxIntervalMs);
+    }
+    throw new BatchJobsError("request_failed", `Batch job ${jobId} did not reach a terminal state within ${maxAttempts} polls`);
+}
+//# sourceMappingURL=batch.js.map

package/dist/contracts-core/content.d.ts

@@ -16,7 +16,7 @@ export interface ErrorInfo {
     readonly retryAfterMs?: number;
     readonly cause?: unknown;
 }
-export type ContentBlock = TextContent | ImageContent | AudioContent | FileContent | DocumentContent | ThinkingContent | ToolCallDeltaContent | ToolCallContent | ToolResultContent;
+export type ContentBlock = TextContent | ImageContent | AudioContent | FileContent | DocumentContent | VideoContent | ThinkingContent | ToolCallDeltaContent | ToolCallContent | ToolResultContent;
 export interface TextContent {
     readonly type: "text";
     readonly text: string;
@@ -30,6 +30,19 @@ export interface ImageContent {
     readonly name?: string;
     readonly metadata?: Readonly<Record<string, unknown>>;
 }
+export interface VideoContent {
+    readonly type: "video";
+    readonly mediaType?: string;
+    readonly name?: string;
+    /** Base64-encoded video bytes. */
+    readonly data?: string;
+    readonly url?: string;
+    readonly resourceUri?: string;
+    readonly durationMs?: number;
+    /** Frame-sampling hint for providers that downsample (e.g. Qwen-VL defaults to 2.0). */
+    readonly fps?: number;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
 export interface ThinkingContent {
     readonly type: "thinking";
     readonly text: string;
@@ -92,6 +105,22 @@ export interface ModelCapabilities {
     readonly streaming?: boolean;
     /** Native JSON-schema structured output support for this model. */
     readonly structuredOutput?: boolean | "json_schema";
+    /** Provider-neutral embeddings generation support (plan 061). */
+    readonly embeddings?: boolean;
+    /** Portable thinking/reasoning effort levels this model declares, ascending ladder order (`none` < `minimal` < `low` < `medium` < `high` < `xhigh` < `max`). Advisory legality metadata for hosts; absent means forward-compat passthrough (phase 65). */
+    readonly thinkingLevels?: readonly string[];
+    /** Provider-neutral speech synthesis support (plan 061). */
+    readonly speech?: boolean;
+    /** Provider-neutral speech transcription support (plan 061). */
+    readonly transcription?: boolean;
+    /** Provider-neutral image generation/editing support (plan 061). */
+    readonly imageGeneration?: boolean;
+    /** Provider-neutral video generation support (plan 061). */
+    readonly videoGeneration?: boolean;
+    /** Provider-neutral moderation classification support (plan 061). */
+    readonly moderation?: boolean;
+    /** Provider-neutral async batch-jobs support (plan 061). */
+    readonly batchJobs?: boolean;
 }
 export interface ModelLimits {
     readonly contextWindow?: number;
@@ -105,6 +134,36 @@ export interface ModelCost {
     readonly currency?: string;
     readonly unit?: string;
 }
+/** Normalized model-list/capability discovery provenance (plan 062): where a
+ *  listing came from, when, and how long hosts may cache it. */
+export interface ModelDiscoveryProvenance {
+    readonly provider: string;
+    /** ISO-8601 timestamp of the fetch (or catalog snapshot) moment. */
+    readonly fetchedAt: string;
+    /** `"api"` = live provider listing; `"catalog"` = host/registry snapshot, no network. */
+    readonly source: "api" | "catalog";
+    /** Cache-TTL guidance in milliseconds; hosts may serve the result from cache this long. */
+    readonly ttlMs?: number;
+}
+export interface ModelDiscoveryOptions {
+    /** Cache window in ms; within TTL a cached result is returned without network.
+     *  `0` forces a refresh. Defaults to the adapter's configured TTL. */
+    readonly ttlMs?: number;
+    readonly signal?: AbortSignal;
+}
+/** Normalized `listModels()` result: the existing `ModelConfig` contract verbatim
+ *  (id = `model`, context window = `limits`, capabilities = `capabilities`, pricing
+ *  hint = `cost`) plus provenance. No new model shape ships. */
+export interface ModelDiscoveryResult {
+    readonly models: readonly ModelConfig[];
+    readonly provenance: ModelDiscoveryProvenance;
+}
+/** Model-list/capability discovery seam (plan 062). Adapter implementations
+ *  normalize provider listings to `ModelConfig` and cache per provider within
+ *  the configured TTL; hosts merge their own catalog overrides on top. */
+export interface ModelDiscovery {
+    listModels(options?: ModelDiscoveryOptions): Promise<ModelDiscoveryResult>;
+}
 export interface Usage {
     readonly inputTokens?: number;
     readonly outputTokens?: number;
@@ -114,3 +173,15 @@ export interface Usage {
     readonly cost?: number;
     readonly currency?: string;
 }
+/**
+ * Host-supplied pricing adapter (plan 062): quotes cost rates per model id. Core
+ * ships no pricing tables — when no catalog is configured, usage is reported
+ * without cost fields. Quotes follow the repo-wide `per_million_tokens` unit
+ * convention (see {@link ModelCost}); a stale or unknown model must resolve to
+ * `undefined` (degrades to usage-only), never throw.
+ */
+export interface CostCatalog {
+    get(modelId: string, options?: {
+        readonly signal?: AbortSignal;
+    }): Promise<ModelCost | undefined>;
+}

package/dist/contracts-core/embeddings.d.ts

@@ -0,0 +1,30 @@
+/** Provider-neutral embeddings contract (plan 061 Task 2).
+ *  One-shot batch shape: the request carries the abort signal, results report the
+ *  shared `Usage`. Adapters enforce provider batch caps with typed errors — they
+ *  never silently auto-chunk; callers chunk (e.g. memory's `embedBatched`).
+ *  ponytail: per-item token caps are server-enforced; the local cap is batch count. */
+import type { ModelCapabilities, ModelConfig, Usage } from "./content.js";
+export interface EmbeddingsRequest {
+    readonly model: string;
+    readonly inputs: readonly string[];
+    /** Output dimensions override; only for models that support reduced dimensions. */
+    readonly dimensions?: number;
+    readonly signal?: AbortSignal;
+}
+export interface EmbeddingsResult {
+    /** Vectors in input order; `vectors[i]` corresponds to `inputs[i]`. */
+    readonly vectors: readonly (readonly number[])[];
+    readonly usage: Usage;
+    readonly dimensions: number;
+}
+export interface EmbeddingsProvider {
+    readonly id: string;
+    embedMany(request: EmbeddingsRequest): Promise<EmbeddingsResult>;
+}
+export type EmbeddingsErrorCode = "empty_input" | "batch_too_large" | "request_failed" | "response_malformed" | "unsupported_model";
+export declare class EmbeddingsError extends Error {
+    readonly code: EmbeddingsErrorCode;
+    constructor(code: EmbeddingsErrorCode, message: string);
+}
+export declare function modelSupportsEmbeddings(capabilities?: ModelCapabilities): boolean;
+export declare function assertEmbeddingsSupported(model: ModelConfig): void;

package/dist/contracts-core/embeddings.js

@@ -0,0 +1,17 @@
+export class EmbeddingsError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = "EmbeddingsError";
+        this.code = code;
+    }
+}
+export function modelSupportsEmbeddings(capabilities) {
+    return capabilities?.embeddings === true;
+}
+export function assertEmbeddingsSupported(model) {
+    if (!modelSupportsEmbeddings(model.capabilities)) {
+        throw new EmbeddingsError("unsupported_model", `Model ${model.provider}/${model.model} does not declare the embeddings capability`);
+    }
+}
+//# sourceMappingURL=embeddings.js.map

package/dist/contracts-core/images.d.ts

@@ -0,0 +1,60 @@
+/** Provider-neutral image generation/editing contract (plan 061 Task 4).
+ *  Generate (prompt→image[s]) and edit (image+mask+prompt) returning `Uint8Array`
+ *  bytes plus provenance — hosts own persistence (no disk writes, no URL-only
+ *  contract). Edit inputs reuse the existing `ImageContent` binary content parts.
+ *  Adapters enforce prompt/content caps with typed errors — they never truncate. */
+import type { ImageContent, ModelCapabilities, ModelConfig, Usage } from "./content.js";
+export interface ImageGenerationRequest {
+    readonly model: string;
+    readonly prompt: string;
+    /** Pixel dimensions, e.g. `1024x1024` (provider-defined vocabulary). */
+    readonly size?: string;
+    /** Output container, e.g. `png`, `jpeg`, `webp`. */
+    readonly format?: string;
+    /** Provider-defined quality tier, e.g. `standard` | `hd`. */
+    readonly quality?: string;
+    /** Number of images to generate (within the provider cap). */
+    readonly count?: number;
+    readonly signal?: AbortSignal;
+}
+export interface ImageEditRequest {
+    readonly model: string;
+    readonly prompt: string;
+    /** Base image(s) as existing binary content parts (base64 `data` or `url`). */
+    readonly images: readonly ImageContent[];
+    /** Optional mask as an image content part (transparent areas mark edits). */
+    readonly mask?: ImageContent;
+    readonly size?: string;
+    readonly format?: string;
+    readonly count?: number;
+    readonly signal?: AbortSignal;
+}
+/** One generated image: bytes plus provenance. `provider`/`model` are preserved
+ *  end-to-end so hosts can attribute stored output. */
+export interface GeneratedImage {
+    readonly bytes: Uint8Array;
+    /** e.g. `image/png`. */
+    readonly mimeType: string;
+    readonly provider: string;
+    readonly model: string;
+    /** Provider-native URL passthrough, when the provider returns one. */
+    readonly url?: string;
+    /** Provider-revised prompt, when the provider returns one. */
+    readonly revisedPrompt?: string;
+}
+export interface ImageGenerationResult {
+    readonly images: readonly GeneratedImage[];
+    readonly usage?: Usage;
+}
+export interface ImageGenerationProvider {
+    readonly id: string;
+    generate(request: ImageGenerationRequest): Promise<ImageGenerationResult>;
+    edit(request: ImageEditRequest): Promise<ImageGenerationResult>;
+}
+export type ImageGenerationErrorCode = "empty_input" | "input_too_large" | "unsupported_operation" | "request_failed" | "response_malformed" | "unsupported_model";
+export declare class ImageGenerationError extends Error {
+    readonly code: ImageGenerationErrorCode;
+    constructor(code: ImageGenerationErrorCode, message: string);
+}
+export declare function modelSupportsImageGeneration(capabilities?: ModelCapabilities): boolean;
+export declare function assertImageGenerationSupported(model: ModelConfig): void;

package/dist/contracts-core/images.js

@@ -0,0 +1,17 @@
+export class ImageGenerationError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = "ImageGenerationError";
+        this.code = code;
+    }
+}
+export function modelSupportsImageGeneration(capabilities) {
+    return capabilities?.imageGeneration === true;
+}
+export function assertImageGenerationSupported(model) {
+    if (!modelSupportsImageGeneration(model.capabilities)) {
+        throw new ImageGenerationError("unsupported_model", `Model ${model.provider}/${model.model} does not declare the imageGeneration capability`);
+    }
+}
+//# sourceMappingURL=images.js.map

package/dist/contracts-core/moderation.d.ts

@@ -0,0 +1,46 @@
+/** Provider-neutral moderation classification contract (plan 061 Task 6).
+ *
+ * Scores and flagged booleans are provider output — core bakes in no policy:
+ * thresholds, blocking, and routing stay host-owned (see docs/host-security.md).
+ * Category keys use the provider-neutral vocabulary below; raw provider
+ * categories that have no neutral mapping pass through untouched.
+ */
+import type { JsonObject, ModelCapabilities, ModelConfig } from "./content.js";
+/** Provider-neutral category vocabulary (canonical names; adapters map their raw
+ *  categories onto these — unknown raw categories pass through as-is). */
+export declare const MODERATION_CATEGORIES: readonly ["harassment", "harassment/threatening", "hate", "hate/threatening", "illicit", "illicit/violent", "self-harm", "self-harm/instructions", "self-harm/intent", "sexual", "sexual/minors", "violence", "violence/graphic"];
+export type ModerationCategory = (typeof MODERATION_CATEGORIES)[number];
+export type ModerationErrorCode = "empty_input" | "input_too_large" | "unsupported_model" | "request_failed" | "response_malformed" | "unsupported_operation";
+export declare class ModerationError extends Error {
+    readonly code: ModerationErrorCode;
+    constructor(code: ModerationErrorCode, message: string);
+}
+export declare function modelSupportsModeration(capabilities?: ModelCapabilities): boolean;
+export declare function assertModerationSupported(model: ModelConfig): void;
+export interface ModerationRequest {
+    /** One input per call, or a batch where the provider allows it (results match
+     *  input arity and order). */
+    readonly input: string | readonly string[];
+    readonly model?: string;
+    readonly signal?: AbortSignal;
+}
+/** Per-category verdict: provider-reported score in [0,1] plus the provider's own
+ *  flagged decision — never a locally recomputed threshold. */
+export interface ModerationCategoryResult {
+    readonly score: number;
+    readonly flagged: boolean;
+}
+export interface ModerationResult {
+    /** True when the provider flagged any category for this input. */
+    readonly flagged: boolean;
+    /** Category verdicts keyed by provider-neutral name (unknown raw categories pass through). */
+    readonly categories: Readonly<Record<string, ModerationCategoryResult>>;
+    /** Provider-native category/score fields, unmodified, for host-side audits. */
+    readonly raw?: JsonObject;
+    readonly model?: string;
+    readonly id?: string;
+}
+export interface ModerationProvider {
+    readonly id: string;
+    moderate(request: ModerationRequest): Promise<ModerationResult | readonly ModerationResult[]>;
+}

package/dist/contracts-core/moderation.js

@@ -0,0 +1,34 @@
+/** Provider-neutral category vocabulary (canonical names; adapters map their raw
+ *  categories onto these — unknown raw categories pass through as-is). */
+export const MODERATION_CATEGORIES = [
+    "harassment",
+    "harassment/threatening",
+    "hate",
+    "hate/threatening",
+    "illicit",
+    "illicit/violent",
+    "self-harm",
+    "self-harm/instructions",
+    "self-harm/intent",
+    "sexual",
+    "sexual/minors",
+    "violence",
+    "violence/graphic",
+];
+export class ModerationError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = "ModerationError";
+        this.code = code;
+    }
+}
+export function modelSupportsModeration(capabilities) {
+    return capabilities?.moderation === true;
+}
+export function assertModerationSupported(model) {
+    if (!modelSupportsModeration(model.capabilities)) {
+        throw new ModerationError("unsupported_model", `Model ${model.provider}/${model.model} does not declare the moderation capability`);
+    }
+}
+//# sourceMappingURL=moderation.js.map