@arnilo/prism 0.4.0 → 0.5.1

package/dist/node/settings.js

@@ -1,11 +1,6 @@
-import { homedir } from "node:os";
-import { join } from "node:path";
 import { mergeConfigLayers } from "../config.js";
 import { createStaticSettingsProvider } from "../settings.js";
 import { isNodeErrorCode, readConfigFile } from "./config.js";
-export function defaultUserSettingsPath(appName = "prism") {
-    return join(homedir(), ".config", appName, "settings.json");
-}
 export function readSettingsFile(path) {
     return readConfigFile(path);
 }

package/dist/pinned-fetch.js

@@ -99,7 +99,11 @@ export async function requestPinned(url, address, init, errorPrefix = "Request")
         const nodeRequest = request(url, {
             method,
             headers: Object.fromEntries(headers.entries()),
-            signal: init?.signal ?? undefined,
+            // NOTE: the caller signal is NOT passed as the http.request `signal` option:
+            // Node's internal abort wiring destroys the (possibly keep-alive, already
+            // completed) socket with the abort reason, surfacing it as an unhandled
+            // socket 'error' when the response resolved and nothing listens anymore.
+            // Abort is handled manually below with a reason-less destroy.
             lookup: ((_hostname, options, callback) => {
                 if (options.all)
                     callback(null, [{ address: address.address, family: address.family }]);
@@ -132,8 +136,13 @@ export async function requestPinned(url, address, init, errorPrefix = "Request")
                             controller.error(error);
                         }
                     },
-                    cancel(reason) {
-                        incoming.destroy(reason instanceof Error ? reason : undefined);
+                    cancel() {
+                        // Destroy WITHOUT the abort reason: once the response resolved,
+                        // nothing listens on the socket, and propagate-destroy(reason)
+                        // surfaces the DOMException as an unhandled socket 'error'
+                        // (SDK transports abort their controller on close()). Readers
+                        // that still pull observe EOF via the iterator.
+                        incoming.destroy();
                     },
                 });
             resolve(new Response(stream, {
@@ -143,12 +152,29 @@ export async function requestPinned(url, address, init, errorPrefix = "Request")
             }));
         });
         nodeRequest.on("error", reject);
+        if (init?.signal) {
+            const signal = init.signal;
+            if (signal.aborted) {
+                reject(abortReason(signal));
+                nodeRequest.destroy();
+            }
+            else {
+                signal.addEventListener("abort", () => {
+                    nodeRequest.destroy();
+                    reject(abortReason(signal));
+                }, { once: true });
+            }
+        }
         if (body)
             nodeRequest.end(body);
         else
             nodeRequest.end();
     });
 }
+function abortReason(signal) {
+    const reason = signal.reason;
+    return reason instanceof Error ? reason : new Error(String(reason));
+}
 async function requestBody(body, errorPrefix) {
     if (body === undefined || body === null)
         return undefined;

package/dist/provider-events.js

@@ -27,10 +27,9 @@ export function reconstructToolCallDeltas(events) {
         if (event.type !== "tool_call_delta")
             continue;
         const partial = partials.get(event.index) ?? { argumentsText: "" };
-        if (event.id !== undefined)
-            partial.id = event.id;
-        if (event.name !== undefined)
-            partial.name = event.name;
+        // Conformant OpenAI-compatible providers repeat identity as null on continuation chunks; coalesce like openai-compatible.js instead of clobbering.
+        partial.id = event.id ?? partial.id;
+        partial.name = event.name ?? partial.name;
         if (event.argumentsText !== undefined)
             partial.argumentsText += event.argumentsText;
         partials.set(event.index, partial);

package/dist/provider-request-policy.d.ts

@@ -3,6 +3,21 @@ export interface SessionCachePolicyOptions {
     readonly retention?: CacheRetention;
     readonly cacheKey?: string;
 }
+export interface ApplyDefaultProviderRequestOptionsContext {
+    readonly sessionId?: string;
+    readonly thinkingLevel?: string;
+}
+export declare class ProviderRequirementError extends Error {
+    readonly code: "ERR_PRISM_PROVIDER_REQUIREMENT";
+    readonly requirement: string;
+    readonly providerId?: string;
+    constructor(message: string, options: {
+        readonly requirement: string;
+        readonly providerId?: string;
+    });
+}
+/** Fill-if-missing `sessionId` / `cacheKey` / cache defaults from `model.cache`. Host values win. Thinking intent patches after. */
+export declare function applyDefaultProviderRequestOptions(request: ProviderRequest, ctx?: ApplyDefaultProviderRequestOptionsContext): ProviderRequest;
 export declare function createProviderRequestPolicyChain(policies: readonly ProviderRequestPolicy[]): ProviderRequestPolicy;
 export declare function createSessionCachePolicy(options?: SessionCachePolicyOptions): ProviderRequestPolicy;
 export declare function mergeProviderRequestOptions(base: ProviderRequestOptions | undefined, patch: ProviderRequestOptions | undefined): ProviderRequestOptions | undefined;

package/dist/provider-request-policy.js

@@ -1,3 +1,55 @@
+import { applyThinkingLevelForModel } from "./thinking.js";
+export class ProviderRequirementError extends Error {
+    code = "ERR_PRISM_PROVIDER_REQUIREMENT";
+    requirement;
+    providerId;
+    constructor(message, options) {
+        super(message);
+        this.name = "ProviderRequirementError";
+        this.requirement = options.requirement;
+        this.providerId = options.providerId;
+    }
+}
+function present(value) {
+    return value ? value : undefined;
+}
+const DEFAULT_CACHE_BREAKPOINTS = [
+    { location: "system_prompt" },
+    { location: "last_stable_message" },
+];
+function defaultCacheOptions(request) {
+    const cache = request.model.cache;
+    if (!cache || (cache.kind !== "cache_control" && cache.explicitBreakpoints !== true))
+        return undefined;
+    const options = request.options;
+    if (options?.cache?.mode === "off" || options?.cacheRetention === "none" || options?.cache?.breakpoints?.length) {
+        return undefined;
+    }
+    return {
+        ...(options?.cacheRetention ? {} : { cacheRetention: "short" }),
+        cache: { breakpoints: DEFAULT_CACHE_BREAKPOINTS },
+    };
+}
+/** Fill-if-missing `sessionId` / `cacheKey` / cache defaults from `model.cache`. Host values win. Thinking intent patches after. */
+export function applyDefaultProviderRequestOptions(request, ctx = {}) {
+    const sessionId = present(request.options?.sessionId) ?? present(ctx.sessionId);
+    const cacheKey = present(request.options?.cacheKey) ?? sessionId;
+    const cachePatch = defaultCacheOptions(request);
+    const thinkingLevel = present(ctx.thinkingLevel);
+    if (sessionId === present(request.options?.sessionId) &&
+        cacheKey === present(request.options?.cacheKey) &&
+        !cachePatch &&
+        !thinkingLevel) {
+        return request;
+    }
+    const merged = mergeProviderRequestOptions(request.options, {
+        ...(sessionId !== undefined ? { sessionId } : {}),
+        ...(cacheKey !== undefined ? { cacheKey } : {}),
+        ...cachePatch,
+    });
+    const options = thinkingLevel ? applyThinkingLevelForModel(merged, thinkingLevel, request.model) : merged;
+    return { ...request, options };
+}
 export function createProviderRequestPolicyChain(policies) {
     return {
         name: "provider-request-policy-chain",

package/dist/providers/media.d.ts

@@ -1,5 +1,5 @@
 import { type MediaContentBlock, type ModelInputCapability, type ResolvedMediaContent, type ResolveMediaContentOptions } from "../content.js";
-import type { AudioContent, ContentBlock, DocumentContent, FileContent, JsonObject, Message, ModelCapabilities, ModelConfig } from "../contracts.js";
+import type { ContentBlock, JsonObject, Message, ModelCapabilities, ModelConfig } from "../contracts.js";
 /** Default upload-cache entry cap per provider media session. */
 export declare const DEFAULT_PROVIDER_UPLOAD_CACHE_ENTRIES = 32;
 /** Inline OpenAI file_data ceiling before preferring Files API upload. */
@@ -37,7 +37,6 @@ export declare function serializePdfDocumentWireBlock(options: {
     readonly data: string;
     readonly title?: string;
 }): JsonObject;
-export declare function resolveProviderMediaBlock(block: AudioContent | FileContent | DocumentContent, options?: ResolveMediaContentOptions): Promise<ResolvedMediaContent>;
 /** Resolve every media block once and enforce aggregate request bounds before provider I/O. */
 export declare function resolveProviderMediaMessages(messages: readonly Message[], model: ModelConfig, options?: ResolveMediaContentOptions): Promise<ReadonlyMap<MediaContentBlock, ResolvedMediaContent>>;
 export declare function defaultProviderFilename(block: MediaContentBlock, fallback: string): string;

package/dist/providers/media.js

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { assertMessagesSupportModelCapabilities, contentBlockInputModality, DEFAULT_MAX_MEDIA_ITEM_BYTES, resolveMediaContentBlock, resolveMediaContentBlocks, UnsupportedModalityError, } from "../content.js";
+import { assertMessagesSupportModelCapabilities, contentBlockInputModality, DEFAULT_MAX_MEDIA_ITEM_BYTES, resolveMediaContentBlocks, UnsupportedModalityError, } from "../content.js";
 /** Default upload-cache entry cap per provider media session. */
 export const DEFAULT_PROVIDER_UPLOAD_CACHE_ENTRIES = 32;
 /** Inline OpenAI file_data ceiling before preferring Files API upload. */
@@ -93,9 +93,6 @@ export function serializePdfDocumentWireBlock(options) {
         ...(options.title ? { title: options.title } : {}),
     };
 }
-export async function resolveProviderMediaBlock(block, options = {}) {
-    return resolveMediaContentBlock(block, options);
-}
 /** Resolve every media block once and enforce aggregate request bounds before provider I/O. */
 export async function resolveProviderMediaMessages(messages, model, options = {}) {
     assertMessagesSupportModelCapabilities(model, messages);

package/dist/rpc.d.ts

@@ -8,7 +8,7 @@ export interface RpcRequest {
     readonly params?: Record<string, unknown>;
 }
 export interface RpcSessionFactory {
-    createSession(id?: string): AgentSession;
+    createSession(id?: string): AgentSession | Promise<AgentSession>;
     readonly commands?: readonly CommandDefinition[];
     /** Host-opt-in driver capabilities forwarded to contributed commands on the
      *  `command` execution context. Absent ⇒ context shape unchanged. */

package/dist/rpc.js

@@ -2,7 +2,7 @@ import { createInterface } from "node:readline";
 import { resolveInstructionInjectors } from "./instruction-injection.js";
 import { errorToErrorInfo } from "./redaction.js";
 export async function runRpcServer(options) {
-    const first = options.createSession();
+    const first = await options.createSession();
     const state = {
         current: first,
         currentHandleId: first.id,
@@ -140,7 +140,7 @@ async function handleRequest(request, state, stdout, activeRuns) {
             const handleId = stringParam(request.params, "handleId") ?? stringParam(request.params, "sessionId") ?? stringParam(request.params, "id");
             if (!handleId)
                 throw new Error("switchSession requires params.handleId (or sessionId)");
-            const session = state.sessions.get(handleId) ?? makeSession(state, handleId);
+            const session = state.sessions.get(handleId) ?? (await makeSession(state, handleId));
             state.current = session;
             state.currentHandleId = handleId;
             write(stdout, { id: request.id, ok: true, result: { sessionId: session.id, leafId: session.leafId, handleId } });
@@ -220,8 +220,8 @@ function registerSession(state, session, preferredHandleId) {
     state.sessions.set(handleId, session);
     return handleId;
 }
-function makeSession(state, id) {
-    const session = state.createSession(id);
+async function makeSession(state, id) {
+    const session = await state.createSession(id);
     state.sessions.set(session.id, session);
     return session;
 }

package/dist/testing/provider-conformance.d.ts

@@ -1,4 +1,4 @@
-import type { AIProvider, ContentBlock, JsonObject, ProviderEvent, ProviderRequest, ToolCallContent, Usage } from "../contracts.js";
+import type { AIProvider, BatchJobsProvider, BatchRequestItem, ContentBlock, EmbeddingsProvider, EmbeddingsResult, ImageGenerationProvider, ImageGenerationResult, JsonObject, ModerationProvider, ModerationResult, ProviderEvent, ProviderRequest, SpeechProvider, SpeechResult, ToolCallContent, TranscriptionProvider, TranscriptionResult, Usage, VideoGenerationJob, VideoGenerationProvider } from "../contracts.js";
 export interface ProviderStreamConformanceOptions {
     readonly provider: AIProvider;
     readonly request: ProviderRequest;
@@ -29,10 +29,6 @@ export interface ProviderHeaderOwnershipConformanceOptions {
     /** Caller-supplied headers, including attempts to override owned names and non-owned additions. */
     readonly caller: Readonly<Record<string, string>>;
 }
-export interface ProviderSecretLeakConformanceOptions {
-    readonly events: readonly ProviderEvent[];
-    readonly secrets: readonly string[];
-}
 export declare function collectProviderEvents(provider: AIProvider, request: ProviderRequest): Promise<readonly ProviderEvent[]>;
 export declare function assertProviderStreamConforms(options: ProviderStreamConformanceOptions): Promise<readonly ProviderEvent[]>;
 export declare function assertAbortIsObserved(options: ProviderAbortConformanceOptions): Promise<void>;
@@ -51,3 +47,116 @@ export declare function assertNoForeignCacheFields(body: unknown, allowed?: read
 /** Provider construction and setup must perform zero network calls; discovery and streams are caller-gated. */
 export declare function assertNoFetches(calls: readonly unknown[]): void;
 export declare function assertUsageAccounting(events: readonly ProviderEvent[], expected: Usage): Usage;
+export interface EmbeddingsConformanceOptions {
+    readonly provider: EmbeddingsProvider;
+    readonly model: string;
+    /** When set, an oversized batch must fail with `EmbeddingsError("batch_too_large")`. */
+    readonly maxBatchSize?: number;
+    /** Happy-path mapping probe: inputs to embed and the expected vector count/dimensions. */
+    readonly sample?: {
+        readonly inputs: readonly string[];
+        readonly dimensions?: number;
+    };
+}
+/** Offline conformance for any `EmbeddingsProvider` (plan 061): typed empty-input
+ *  error, typed oversized-batch error, and input-order vector mapping with finite
+ *  coordinates. No network — the caller supplies the provider (real adapter with a
+ *  fake transport, or a fake provider). */
+export declare function runEmbeddingsConformance(options: EmbeddingsConformanceOptions): Promise<EmbeddingsResult | undefined>;
+export interface SpeechConformanceOptions {
+    readonly provider: SpeechProvider;
+    readonly model: string;
+    /** When set, an oversized input must fail with `SpeechError("input_too_large")`. */
+    readonly maxInputChars?: number;
+    /** Happy-path probe: text to synthesize, optional voice/format. */
+    readonly sample?: {
+        readonly input?: string;
+        readonly voice?: string;
+        readonly format?: string;
+    };
+}
+/** Offline conformance for any `SpeechProvider` (plan 061): typed empty-input and
+ *  oversized-input errors, byte results, and stream ordering — the stream must emit
+ *  at least one chunk before closing. Asserts event order, never wall clock. */
+export declare function runSpeechConformance(options: SpeechConformanceOptions): Promise<SpeechResult | undefined>;
+export interface TranscriptionConformanceOptions {
+    readonly provider: TranscriptionProvider;
+    readonly model: string;
+    /** When set, oversized audio must fail with `TranscriptionError("audio_too_large")`. */
+    readonly maxAudioBytes?: number;
+    /** Happy-path probe: audio bytes and the expected transcript prefix. */
+    readonly sample?: {
+        readonly audio?: Uint8Array;
+        readonly format?: string;
+        readonly textIncludes?: string;
+    };
+}
+/** Offline conformance for any `TranscriptionProvider` (plan 061): typed empty-audio
+ *  and oversized-audio errors, one-shot text, and stream ordering — at least one
+ *  `transcript_delta` partial, then exactly one `done` terminal event. */
+export declare function runTranscriptionConformance(options: TranscriptionConformanceOptions): Promise<TranscriptionResult | undefined>;
+export interface ImageGenerationConformanceOptions {
+    readonly provider: ImageGenerationProvider;
+    readonly model: string;
+    /** When set, an oversized prompt must fail with `ImageGenerationError("input_too_large")`. */
+    readonly maxPromptChars?: number;
+    /** Happy-path probe: prompt, requested image count, expected provenance. */
+    readonly sample?: {
+        readonly prompt?: string;
+        readonly size?: string;
+        readonly count?: number;
+    };
+}
+/** Offline conformance for any `ImageGenerationProvider` (plan 061): typed empty-input
+ *  and oversized-prompt errors, plus image shape — non-empty bytes, an `image/*` mime
+ *  type, and preserved provenance (`provider`/`model`) on every image. */
+export declare function runImageGenerationConformance(options: ImageGenerationConformanceOptions): Promise<ImageGenerationResult | undefined>;
+export interface VideoGenerationConformanceOptions {
+    readonly provider: VideoGenerationProvider;
+    readonly model: string;
+    /** When set, an oversized prompt must fail with `VideoGenerationError("input_too_large")`. */
+    readonly maxPromptChars?: number;
+    /** Happy-path lifecycle probe: submit, poll to terminal state, assert result shape. */
+    readonly sample?: {
+        readonly prompt?: string;
+        readonly maxPolls?: number;
+    };
+}
+/** Offline conformance for any `VideoGenerationProvider` (plan 061): typed
+ *  empty-input and oversized-prompt errors, plus the submit→status lifecycle —
+ *  a job id is returned, polling reaches a terminal state, and succeeded jobs
+ *  carry a video with provenance (`provider`/`model`) and at least one source
+ *  (`bytes` or `url`). */
+export declare function runVideoGenerationConformance(options: VideoGenerationConformanceOptions): Promise<VideoGenerationJob | undefined>;
+export interface ModerationConformanceOptions {
+    readonly provider: ModerationProvider;
+    readonly model: string;
+    /** When set, an oversized input must fail with `ModerationError("input_too_large")`. */
+    readonly maxInputChars?: number;
+    /** Happy-path probe: a benign string classification. */
+    readonly sample?: {
+        readonly input?: string;
+    };
+}
+/** Offline conformance for any `ModerationProvider` (plan 061): typed empty-input
+ *  and oversized-input errors, plus a classification probe — every category
+ *  verdict carries a numeric score in [0,1], a boolean `flagged`, and the
+ *  top-level `flagged` boolean is present. Scores are provider output; conformance
+ *  asserts no local policy decisions are baked in. */
+export declare function runModerationConformance(options: ModerationConformanceOptions): Promise<ModerationResult | undefined>;
+export interface BatchJobsConformanceOptions {
+    readonly provider: BatchJobsProvider;
+    /** Sample lifecycle driver: submitted via `submit` and expected to reach `completed`. */
+    readonly sample?: {
+        readonly model: string;
+        readonly requests: readonly BatchRequestItem[];
+    };
+    /** When set, a submit over this count must fail with `BatchJobsError("too_many_requests")`. */
+    readonly maxRequests?: number;
+}
+/** Offline conformance for any `BatchJobsProvider` (plan 061): typed empty/oversized
+ *  submit errors, opaque job ids, status returning members of the neutral state
+ *  union, terminal resolution via `pollBatch` (plain utility), and paged results
+ *  that walk to exhaustion with cursor continuity. Failure/cancel terminal
+ *  transitions are covered by provider fakes in adapter test suites. */
+export declare function runBatchJobsConformance(options: BatchJobsConformanceOptions): Promise<void>;