@nyte-ai/ai 0.0.0-stage → 0.0.18

package/dist/src/api/openai-responses-events.d.ts

@@ -0,0 +1,379 @@
+/**
+ * The Responses stream events the shared processor acts on, as TypeBox schemas. Both the
+ * OpenAI SDK stream and Codex's raw frames are checked against them once, at the processor's
+ * ingress; events of other types, or missing the fields read, are skipped.
+ */
+import { type Static, Type } from "typebox";
+declare const OutputItemSchema: Type.TUnion<[Type.TObject<{
+    type: Type.TLiteral<"reasoning">;
+    id: Type.TString;
+    summary: Type.TOptional<Type.TArray<Type.TObject<{
+        text: Type.TString;
+    }>>>;
+    content: Type.TOptional<Type.TArray<Type.TObject<{
+        text: Type.TString;
+    }>>>;
+    encrypted_content: Type.TOptional<Type.TUnion<[Type.TString, Type.TNull]>>;
+}>, Type.TObject<{
+    type: Type.TLiteral<"message">;
+    id: Type.TOptional<Type.TString>;
+    phase: Type.TOptional<Type.TUnion<[Type.TLiteral<"commentary">, Type.TLiteral<"final_answer">, Type.TNull]>>;
+    content: Type.TOptional<Type.TArray<Type.TUnion<[Type.TObject<{
+        type: Type.TLiteral<"output_text">;
+        text: Type.TString;
+    }>, Type.TObject<{
+        type: Type.TLiteral<"refusal">;
+        refusal: Type.TString;
+    }>]>>>;
+}>, Type.TObject<{
+    type: Type.TLiteral<"function_call">;
+    id: Type.TOptional<Type.TString>;
+    call_id: Type.TString;
+    name: Type.TString;
+    arguments: Type.TOptional<Type.TString>;
+    namespace: Type.TOptional<Type.TString>;
+}>, Type.TObject<{
+    type: Type.TLiteral<"custom_tool_call">;
+    id: Type.TOptional<Type.TString>;
+    call_id: Type.TString;
+    name: Type.TString;
+    input: Type.TOptional<Type.TString>;
+    namespace: Type.TOptional<Type.TString>;
+}>]>;
+export type ResponsesOutputItem = Static<typeof OutputItemSchema>;
+/** A reasoning item in a terminal response's output, for backfilling its encrypted content. */
+export declare const TerminalReasoningItemSchema: Type.TObject<{
+    type: Type.TLiteral<"reasoning">;
+    id: Type.TString;
+    encrypted_content: Type.TOptional<Type.TUnion<[Type.TString, Type.TNull]>>;
+}>;
+/** A stored reasoning item: what the processor serialized into a thinking signature. */
+export declare const StoredReasoningItemSchema: Type.TObject<{
+    type: Type.TLiteral<"reasoning">;
+    encrypted_content: Type.TOptional<Type.TUnion<[Type.TString, Type.TNull]>>;
+}>;
+declare const ResponseStatusSchema: Type.TUnion<[Type.TLiteral<"completed">, Type.TLiteral<"failed">, Type.TLiteral<"in_progress">, Type.TLiteral<"cancelled">, Type.TLiteral<"queued">, Type.TLiteral<"incomplete">]>;
+export type ResponsesStatus = Static<typeof ResponseStatusSchema>;
+/** A service tier as the Responses API reports it; GPT-6 reports Fast mode as `fast`. */
+export declare const ServiceTierSchema: Type.TUnion<[Type.TLiteral<"auto">, Type.TLiteral<"default">, Type.TLiteral<"flex">, Type.TLiteral<"scale">, Type.TLiteral<"priority">, Type.TLiteral<"fast">, Type.TNull]>;
+export type ResponsesServiceTier = Static<typeof ServiceTierSchema>;
+/**
+ * The terminal response metadata the processor reads. Usage and service tier stay unknown
+ * here: the finalizer validates usage itself so an invalid count fails as a usage error, and an
+ * unrecognized tier is ignored rather than dropping the terminal event.
+ */
+declare const TerminalResponseSchema: Type.TObject<{
+    id: Type.TOptional<Type.TString>;
+    status: Type.TOptional<Type.TUnion<[Type.TLiteral<"completed">, Type.TLiteral<"failed">, Type.TLiteral<"in_progress">, Type.TLiteral<"cancelled">, Type.TLiteral<"queued">, Type.TLiteral<"incomplete">]>>;
+    incomplete_details: Type.TOptional<Type.TUnion<[Type.TObject<{
+        reason: Type.TOptional<Type.TString>;
+    }>, Type.TNull]>>;
+    error: Type.TOptional<Type.TUnion<[Type.TObject<{
+        code: Type.TOptional<Type.TUnion<[Type.TString, Type.TNull]>>;
+        message: Type.TOptional<Type.TString>;
+    }>, Type.TNull]>>;
+    output: Type.TOptional<Type.TArray<Type.TUnknown>>;
+    usage: Type.TOptional<Type.TUnknown>;
+    service_tier: Type.TOptional<Type.TUnknown>;
+}>;
+export type ResponsesTerminalResponse = Static<typeof TerminalResponseSchema>;
+/** Checks a raw event; compiled once because it runs for every streamed delta. */
+export declare const ResponsesStreamEventCheck: import("typebox/compile").Validator<{}, Type.TUnion<[Type.TObject<{
+    type: Type.TLiteral<"response.created">;
+    response: Type.TObject<{
+        id: Type.TOptional<Type.TString>;
+    }>;
+}>, Type.TObject<{
+    type: Type.TUnion<[Type.TLiteral<"response.output_item.added">, Type.TLiteral<"response.output_item.done">]>;
+    output_index: Type.TOptional<Type.TNumber>;
+    item: Type.TUnion<[Type.TObject<{
+        type: Type.TLiteral<"reasoning">;
+        id: Type.TString;
+        summary: Type.TOptional<Type.TArray<Type.TObject<{
+            text: Type.TString;
+        }>>>;
+        content: Type.TOptional<Type.TArray<Type.TObject<{
+            text: Type.TString;
+        }>>>;
+        encrypted_content: Type.TOptional<Type.TUnion<[Type.TString, Type.TNull]>>;
+    }>, Type.TObject<{
+        type: Type.TLiteral<"message">;
+        id: Type.TOptional<Type.TString>;
+        phase: Type.TOptional<Type.TUnion<[Type.TLiteral<"commentary">, Type.TLiteral<"final_answer">, Type.TNull]>>;
+        content: Type.TOptional<Type.TArray<Type.TUnion<[Type.TObject<{
+            type: Type.TLiteral<"output_text">;
+            text: Type.TString;
+        }>, Type.TObject<{
+            type: Type.TLiteral<"refusal">;
+            refusal: Type.TString;
+        }>]>>>;
+    }>, Type.TObject<{
+        type: Type.TLiteral<"function_call">;
+        id: Type.TOptional<Type.TString>;
+        call_id: Type.TString;
+        name: Type.TString;
+        arguments: Type.TOptional<Type.TString>;
+        namespace: Type.TOptional<Type.TString>;
+    }>, Type.TObject<{
+        type: Type.TLiteral<"custom_tool_call">;
+        id: Type.TOptional<Type.TString>;
+        call_id: Type.TString;
+        name: Type.TString;
+        input: Type.TOptional<Type.TString>;
+        namespace: Type.TOptional<Type.TString>;
+    }>]>;
+}>, Type.TObject<{
+    type: Type.TLiteral<"response.reasoning_summary_text.delta">;
+    output_index: Type.TOptional<Type.TNumber>;
+    delta: Type.TString;
+}>, Type.TObject<{
+    type: Type.TLiteral<"response.reasoning_summary_part.done">;
+    output_index: Type.TOptional<Type.TNumber>;
+}>, Type.TObject<{
+    type: Type.TLiteral<"response.reasoning_text.delta">;
+    output_index: Type.TOptional<Type.TNumber>;
+    delta: Type.TString;
+}>, Type.TObject<{
+    type: Type.TLiteral<"response.output_text.delta">;
+    output_index: Type.TOptional<Type.TNumber>;
+    delta: Type.TString;
+}>, Type.TObject<{
+    type: Type.TLiteral<"response.refusal.delta">;
+    output_index: Type.TOptional<Type.TNumber>;
+    delta: Type.TString;
+}>, Type.TObject<{
+    type: Type.TLiteral<"response.function_call_arguments.delta">;
+    output_index: Type.TOptional<Type.TNumber>;
+    delta: Type.TString;
+}>, Type.TObject<{
+    type: Type.TLiteral<"response.function_call_arguments.done">;
+    output_index: Type.TOptional<Type.TNumber>;
+    arguments: Type.TString;
+}>, Type.TObject<{
+    type: Type.TLiteral<"response.custom_tool_call_input.delta">;
+    output_index: Type.TOptional<Type.TNumber>;
+    delta: Type.TString;
+}>, Type.TObject<{
+    type: Type.TLiteral<"response.custom_tool_call_input.done">;
+    output_index: Type.TOptional<Type.TNumber>;
+    input: Type.TString;
+}>, Type.TObject<{
+    type: Type.TUnion<[Type.TLiteral<"response.completed">, Type.TLiteral<"response.incomplete">, Type.TLiteral<"response.failed">]>;
+    response: Type.TObject<{
+        id: Type.TOptional<Type.TString>;
+        status: Type.TOptional<Type.TUnion<[Type.TLiteral<"completed">, Type.TLiteral<"failed">, Type.TLiteral<"in_progress">, Type.TLiteral<"cancelled">, Type.TLiteral<"queued">, Type.TLiteral<"incomplete">]>>;
+        incomplete_details: Type.TOptional<Type.TUnion<[Type.TObject<{
+            reason: Type.TOptional<Type.TString>;
+        }>, Type.TNull]>>;
+        error: Type.TOptional<Type.TUnion<[Type.TObject<{
+            code: Type.TOptional<Type.TUnion<[Type.TString, Type.TNull]>>;
+            message: Type.TOptional<Type.TString>;
+        }>, Type.TNull]>>;
+        output: Type.TOptional<Type.TArray<Type.TUnknown>>;
+        usage: Type.TOptional<Type.TUnknown>;
+        service_tier: Type.TOptional<Type.TUnknown>;
+    }>;
+}>, Type.TObject<{
+    type: Type.TLiteral<"error">;
+    code: Type.TOptional<Type.TUnion<[Type.TString, Type.TNull]>>;
+    message: Type.TOptional<Type.TString>;
+}>]>, {
+    type: "response.created";
+    response: {
+        id?: string | undefined;
+    };
+} | {
+    output_index?: number | undefined;
+    type: "response.output_item.added" | "response.output_item.done";
+    item: {
+        content?: {
+            text: string;
+        }[] | undefined;
+        summary?: {
+            text: string;
+        }[] | undefined;
+        encrypted_content?: string | null | undefined;
+        id: string;
+        type: "reasoning";
+    } | {
+        id?: string | undefined;
+        content?: ({
+            text: string;
+            type: "output_text";
+        } | {
+            type: "refusal";
+            refusal: string;
+        })[] | undefined;
+        phase?: "commentary" | "final_answer" | null | undefined;
+        type: "message";
+    } | {
+        id?: string | undefined;
+        arguments?: string | undefined;
+        namespace?: string | undefined;
+        name: string;
+        type: "function_call";
+        call_id: string;
+    } | {
+        id?: string | undefined;
+        input?: string | undefined;
+        namespace?: string | undefined;
+        name: string;
+        type: "custom_tool_call";
+        call_id: string;
+    };
+} | {
+    output_index?: number | undefined;
+    type: "response.reasoning_summary_text.delta";
+    delta: string;
+} | {
+    output_index?: number | undefined;
+    type: "response.reasoning_summary_part.done";
+} | {
+    output_index?: number | undefined;
+    type: "response.reasoning_text.delta";
+    delta: string;
+} | {
+    output_index?: number | undefined;
+    type: "response.output_text.delta";
+    delta: string;
+} | {
+    output_index?: number | undefined;
+    type: "response.refusal.delta";
+    delta: string;
+} | {
+    output_index?: number | undefined;
+    type: "response.function_call_arguments.delta";
+    delta: string;
+} | {
+    output_index?: number | undefined;
+    arguments: string;
+    type: "response.function_call_arguments.done";
+} | {
+    output_index?: number | undefined;
+    type: "response.custom_tool_call_input.delta";
+    delta: string;
+} | {
+    output_index?: number | undefined;
+    input: string;
+    type: "response.custom_tool_call_input.done";
+} | {
+    type: "response.completed" | "response.incomplete" | "response.failed";
+    response: {
+        error?: {
+            message?: string | undefined;
+            code?: string | null | undefined;
+        } | null | undefined;
+        id?: string | undefined;
+        service_tier?: unknown;
+        status?: "failed" | "completed" | "in_progress" | "incomplete" | "cancelled" | "queued" | undefined;
+        usage?: unknown;
+        output?: unknown[] | undefined;
+        incomplete_details?: {
+            reason?: string | undefined;
+        } | null | undefined;
+    };
+} | {
+    message?: string | undefined;
+    code?: string | null | undefined;
+    type: "error";
+}, {
+    type: "response.created";
+    response: {
+        id?: string | undefined;
+    };
+} | {
+    output_index?: number | undefined;
+    type: "response.output_item.added" | "response.output_item.done";
+    item: {
+        content?: {
+            text: string;
+        }[] | undefined;
+        summary?: {
+            text: string;
+        }[] | undefined;
+        encrypted_content?: string | null | undefined;
+        id: string;
+        type: "reasoning";
+    } | {
+        id?: string | undefined;
+        content?: ({
+            text: string;
+            type: "output_text";
+        } | {
+            type: "refusal";
+            refusal: string;
+        })[] | undefined;
+        phase?: "commentary" | "final_answer" | null | undefined;
+        type: "message";
+    } | {
+        id?: string | undefined;
+        arguments?: string | undefined;
+        namespace?: string | undefined;
+        name: string;
+        type: "function_call";
+        call_id: string;
+    } | {
+        id?: string | undefined;
+        input?: string | undefined;
+        namespace?: string | undefined;
+        name: string;
+        type: "custom_tool_call";
+        call_id: string;
+    };
+} | {
+    output_index?: number | undefined;
+    type: "response.reasoning_summary_text.delta";
+    delta: string;
+} | {
+    output_index?: number | undefined;
+    type: "response.reasoning_summary_part.done";
+} | {
+    output_index?: number | undefined;
+    type: "response.reasoning_text.delta";
+    delta: string;
+} | {
+    output_index?: number | undefined;
+    type: "response.output_text.delta";
+    delta: string;
+} | {
+    output_index?: number | undefined;
+    type: "response.refusal.delta";
+    delta: string;
+} | {
+    output_index?: number | undefined;
+    type: "response.function_call_arguments.delta";
+    delta: string;
+} | {
+    output_index?: number | undefined;
+    arguments: string;
+    type: "response.function_call_arguments.done";
+} | {
+    output_index?: number | undefined;
+    type: "response.custom_tool_call_input.delta";
+    delta: string;
+} | {
+    output_index?: number | undefined;
+    input: string;
+    type: "response.custom_tool_call_input.done";
+} | {
+    type: "response.completed" | "response.incomplete" | "response.failed";
+    response: {
+        error?: {
+            message?: string | undefined;
+            code?: string | null | undefined;
+        } | null | undefined;
+        id?: string | undefined;
+        service_tier?: unknown;
+        status?: "failed" | "completed" | "in_progress" | "incomplete" | "cancelled" | "queued" | undefined;
+        usage?: unknown;
+        output?: unknown[] | undefined;
+        incomplete_details?: {
+            reason?: string | undefined;
+        } | null | undefined;
+    };
+} | {
+    message?: string | undefined;
+    code?: string | null | undefined;
+    type: "error";
+}>;
+export {};

package/dist/src/api/openai-responses-events.js

@@ -0,0 +1,12 @@
+import {
+  TerminalReasoningItemSchema2,
+  StoredReasoningItemSchema2,
+  ServiceTierSchema2,
+  ResponsesStreamEventCheck2
+} from "../../chunks/account-limits-cache-a558rjbg.js";
+export {
+  ResponsesStreamEventCheck2 as ResponsesStreamEventCheck,
+  ServiceTierSchema2 as ServiceTierSchema,
+  StoredReasoningItemSchema2 as StoredReasoningItemSchema,
+  TerminalReasoningItemSchema2 as TerminalReasoningItemSchema
+};

package/dist/src/api/openai-responses-stream.d.ts

@@ -0,0 +1,36 @@
+/**
+ * The Responses API event stream processor, shared by the OpenAI Responses and
+ * Codex adapters.
+ */
+import type { ResponseCreateParamsStreaming } from "openai/resources/responses/responses.js";
+import type { Api, AssistantMessage, Model, Usage } from "../types.ts";
+import type { AssistantMessageEventStream } from "../utils/event-stream.ts";
+import { type ResponsesServiceTier } from "./openai-responses-events.ts";
+export declare function withPriorityTier<O extends {
+    fast?: boolean;
+    serviceTier?: ResponseCreateParamsStreaming["service_tier"];
+}>(options: O | undefined): O | undefined;
+export interface OpenAIResponsesStreamOptions {
+    serviceTier?: ResponseCreateParamsStreaming["service_tier"];
+    grammarToolInputProperties?: ReadonlyMap<string, string>;
+    resolveServiceTier?: (responseServiceTier: ResponsesServiceTier | undefined, requestServiceTier: ResponseCreateParamsStreaming["service_tier"] | undefined) => ResponsesServiceTier | undefined;
+    applyServiceTierPricing?: (usage: Usage, serviceTier: ResponsesServiceTier | undefined) => void;
+}
+export declare class ResponsesUsageError extends Error {
+}
+/**
+ * Maps a Responses event stream onto `output`. Each raw event is checked against the event
+ * schemas first; others are skipped.
+ *
+ * - A tool call whose `output_item.done` never arrived may have cut-off or mixed-up arguments,
+ *   e.g. when a non-compliant server omits `output_index`: a `toolUse` stop with one fails the
+ *   stream, and any other stop marks it with `argumentsError` so it is reported, not run.
+ *   Finished calls drop their scratch buffers, so replay carries only parsed arguments.
+ * - Azure OpenAI can omit `encrypted_content` from `output_item.done` and send it only in the
+ *   terminal response's output; it is backfilled into the stored reasoning item, keeping
+ *   `store: false` multi-turn replay stateless.
+ * - `input_tokens` includes cached and cache-write tokens, so both are subtracted.
+ * - An incomplete response keeps its specific reason in `rawStopReason`, so output truncation
+ *   and content filtering stay distinct.
+ */
+export declare function processResponsesStream<TApi extends Api>(openaiStream: AsyncIterable<unknown>, output: AssistantMessage, stream: AssistantMessageEventStream, model: Model<TApi>, options?: OpenAIResponsesStreamOptions): Promise<void>;

package/dist/src/api/openai-responses-stream.js

@@ -0,0 +1,25 @@
+import {
+  withPriorityTier2,
+  ResponsesUsageError2,
+  processResponsesStream2
+} from "../../chunks/account-limits-cache-53e64mhx.js";
+import"../../chunks/account-limits-cache-a558rjbg.js";
+import"../../chunks/account-limits-cache-n3yk6g5c.js";
+import"../../chunks/account-limits-cache-8qzk56vj.js";
+import"../../chunks/account-limits-cache-736tdyme.js";
+import"../../chunks/account-limits-cache-h92bzz1j.js";
+import"../../chunks/account-limits-cache-eqwweapz.js";
+import"../../chunks/account-limits-cache-0af5gqeg.js";
+import"../../chunks/account-limits-cache-b4edaybk.js";
+import"../../chunks/account-limits-cache-6250ykn6.js";
+import"../../chunks/account-limits-cache-fbkaq46e.js";
+import"../../chunks/account-limits-cache-fsktnetm.js";
+import"../../chunks/account-limits-cache-zcbkmrvy.js";
+import"../../chunks/account-limits-cache-a6cgeagz.js";
+import"../../chunks/account-limits-cache-nn9jebsj.js";
+import"../../chunks/account-limits-cache-zgzptd0z.js";
+export {
+  ResponsesUsageError2 as ResponsesUsageError,
+  processResponsesStream2 as processResponsesStream,
+  withPriorityTier2 as withPriorityTier
+};

package/dist/src/api/openai-responses.d.ts

@@ -0,0 +1,18 @@
+import type { ResponseCreateParamsStreaming } from "openai/resources/responses/responses.js";
+import type { Context, Model, SimpleStreamOptions, StreamFunction, StreamOptions } from "../types.ts";
+import { type OpenAICompactResult } from "./openai-compact.ts";
+export interface OpenAIResponsesOptions extends StreamOptions {
+    reasoningEffort?: "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+    reasoningSummary?: "auto" | "detailed" | "concise" | null;
+    serviceTier?: ResponseCreateParamsStreaming["service_tier"];
+    toolChoice?: ResponseCreateParamsStreaming["tool_choice"];
+}
+/**
+ * Compact through OpenAI's stateless endpoint, preserving its complete output window.
+ * https://developers.openai.com/api/docs/guides/compaction#standalone-compact-endpoint
+ * Instructions travel separately, so the input does not repeat the system message.
+ */
+export declare function compactOpenAIResponsesContext(model: Model<"openai-responses">, context: Context, requested?: OpenAIResponsesOptions): Promise<OpenAICompactResult>;
+/** Streams an OpenAI Responses request. */
+export declare const stream: StreamFunction<"openai-responses", OpenAIResponsesOptions>;
+export declare const streamSimple: StreamFunction<"openai-responses", SimpleStreamOptions>;