@zpi-dev/agent-sdk 0.0.0-stage → 0.1.60

package/dist/types/agent-sdk/src/types.d.ts

@@ -0,0 +1,428 @@
+import type { AgentSession, InputContext, ModelRuntime, ParsedInput, ProviderConfigInput, ResourceLoader, SessionManager, SessionPlugin, ToolDefinition } from "../../coding-agent/src/index.js";
+export type UUID = string;
+export type Effort = "low" | "medium" | "high" | "xhigh" | "max";
+export type ThinkingConfig = {
+    type: "disabled";
+} | {
+    type: "adaptive";
+} | {
+    type: "enabled";
+    budgetTokens?: number;
+};
+export type TextBlock = {
+    type: "text";
+    text: string;
+};
+export type ThinkingBlock = {
+    type: "thinking";
+    thinking: string;
+    signature: string;
+};
+export type ToolUseBlock = {
+    type: "tool_use";
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+};
+export type ImageBlock = {
+    type: "image";
+    source: {
+        type: "base64";
+        media_type: string;
+        data: string;
+    };
+};
+export type ToolResultBlock = {
+    type: "tool_result";
+    tool_use_id: string;
+    content: string | (TextBlock | ImageBlock)[];
+    is_error?: boolean;
+};
+export type ContentBlock = TextBlock | ThinkingBlock | ToolUseBlock | ToolResultBlock | ImageBlock;
+export interface Usage {
+    input_tokens: number;
+    output_tokens: number;
+    cache_creation_input_tokens: number;
+    cache_read_input_tokens: number;
+    server_tool_use: {
+        web_search_requests: number;
+        web_fetch_requests: number;
+    };
+}
+export interface ModelUsage {
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadInputTokens: number;
+    cacheCreationInputTokens: number;
+    webSearchRequests: number;
+    costUSD: number;
+    contextWindow: number;
+    maxOutputTokens: number;
+}
+export interface SDKUserMessage {
+    type: "user";
+    uuid?: UUID;
+    session_id?: string;
+    parent_tool_use_id: string | null;
+    message: {
+        role: "user";
+        content: string | (TextBlock | ImageBlock | ToolResultBlock)[];
+    };
+    isSynthetic?: boolean;
+    tool_use_result?: unknown;
+}
+export interface SDKAssistantMessage {
+    type: "assistant";
+    uuid: UUID;
+    session_id: string;
+    parent_tool_use_id: string | null;
+    message: {
+        id: string;
+        type: "message";
+        role: "assistant";
+        model: string;
+        content: (TextBlock | ThinkingBlock | ToolUseBlock)[];
+        stop_reason: "end_turn" | "tool_use" | "max_tokens" | null;
+        stop_sequence: string | null;
+        usage: Usage;
+    };
+    error?: "unknown" | "authentication_failed" | "rate_limit" | "server_error";
+    aborted?: true;
+}
+export interface SDKSystemMessage {
+    type: "system";
+    subtype: "init";
+    uuid: UUID;
+    session_id: string;
+    cwd: string;
+    tools: string[];
+    model: string;
+    apiKeySource: "user" | "env";
+    claude_code_version: string;
+    mcp_servers: never[];
+    slash_commands: string[];
+    output_style: string;
+    skills: string[];
+    plugins: {
+        name: string;
+        path: string;
+    }[];
+    agents?: string[];
+    capabilities?: string[];
+}
+export type RawStreamEvent = {
+    type: "message_start";
+    message: SDKAssistantMessage["message"];
+} | {
+    type: "content_block_start";
+    index: number;
+    content_block: TextBlock | ThinkingBlock | ToolUseBlock;
+} | {
+    type: "content_block_delta";
+    index: number;
+    delta: {
+        type: "text_delta";
+        text: string;
+    } | {
+        type: "thinking_delta";
+        thinking: string;
+    } | {
+        type: "input_json_delta";
+        partial_json: string;
+    };
+} | {
+    type: "content_block_stop";
+    index: number;
+} | {
+    type: "message_delta";
+    delta: {
+        stop_reason: SDKAssistantMessage["message"]["stop_reason"];
+        stop_sequence: null;
+    };
+    usage: Usage;
+} | {
+    type: "message_stop";
+};
+export interface SDKPartialAssistantMessage {
+    type: "stream_event";
+    event: RawStreamEvent;
+    uuid: UUID;
+    session_id: string;
+    parent_tool_use_id: string | null;
+}
+export interface SDKPermissionDenial {
+    tool_name: string;
+    tool_use_id: string;
+    tool_input: Record<string, unknown>;
+}
+interface ResultBase {
+    type: "result";
+    uuid: UUID;
+    session_id: string;
+    duration_ms: number;
+    duration_api_ms: number;
+    num_turns: number;
+    is_error: boolean;
+    stop_reason: string | null;
+    total_cost_usd: number;
+    usage: Usage;
+    modelUsage: Record<string, ModelUsage>;
+    permission_denials: SDKPermissionDenial[];
+}
+export type SDKResultMessage = ResultBase & ({
+    subtype: "success";
+    result: string;
+    structured_output?: unknown;
+} | {
+    subtype: "error_max_turns" | "error_during_execution" | "error_max_budget_usd" | "error_max_structured_output_retries";
+    errors: string[];
+});
+export type HookEvent = "SessionStart" | "SessionEnd" | "UserPromptSubmit" | "PreToolUse" | "PostToolUse" | "PostToolUseFailure" | "Stop" | "SubagentStart" | "SubagentStop" | "PreCompact" | "PostCompact";
+export interface BaseHookInput {
+    session_id: string;
+    transcript_path: string;
+    cwd: string;
+}
+export interface SessionStartHookInput extends BaseHookInput {
+    hook_event_name: "SessionStart";
+    source: string;
+}
+export interface SessionEndHookInput extends BaseHookInput {
+    hook_event_name: "SessionEnd";
+    reason: string;
+}
+export interface UserPromptSubmitHookInput extends BaseHookInput {
+    hook_event_name: "UserPromptSubmit";
+    prompt: string;
+}
+export interface PreToolUseHookInput extends BaseHookInput {
+    hook_event_name: "PreToolUse";
+    tool_name: string;
+    tool_input: Record<string, unknown>;
+    tool_use_id: string;
+}
+export interface PostToolUseHookInput extends Omit<PreToolUseHookInput, "hook_event_name"> {
+    hook_event_name: "PostToolUse";
+    tool_response: unknown;
+}
+export interface PostToolUseFailureHookInput extends Omit<PreToolUseHookInput, "hook_event_name"> {
+    hook_event_name: "PostToolUseFailure";
+    error: string;
+}
+export interface StopHookInput extends BaseHookInput {
+    hook_event_name: "Stop";
+    stop_hook_active: boolean;
+    last_assistant_message?: string;
+}
+export interface SubagentStartHookInput extends BaseHookInput {
+    hook_event_name: "SubagentStart";
+    agent_id: string;
+    agent_type: string;
+}
+export interface SubagentStopHookInput extends Omit<SubagentStartHookInput, "hook_event_name"> {
+    hook_event_name: "SubagentStop";
+    stop_hook_active: boolean;
+    last_assistant_message?: string;
+}
+export interface PreCompactHookInput extends BaseHookInput {
+    hook_event_name: "PreCompact";
+    trigger: "manual" | "auto";
+    custom_instructions: string;
+}
+export interface PostCompactHookInput extends Omit<PreCompactHookInput, "hook_event_name"> {
+    hook_event_name: "PostCompact";
+}
+export type HookInput = SessionStartHookInput | SessionEndHookInput | UserPromptSubmitHookInput | PreToolUseHookInput | PostToolUseHookInput | PostToolUseFailureHookInput | StopHookInput | SubagentStartHookInput | SubagentStopHookInput | PreCompactHookInput | PostCompactHookInput;
+export interface SyncHookJSONOutput {
+    continue?: boolean;
+    stopReason?: string;
+    decision?: "approve" | "block";
+    reason?: string;
+    suppressOutput?: boolean;
+    systemMessage?: string;
+    hookSpecificOutput?: {
+        hookEventName: HookEvent;
+        additionalContext?: string;
+        updatedInput?: Record<string, unknown>;
+        permissionDecision?: "allow" | "deny" | "ask";
+        permissionDecisionReason?: string;
+    };
+}
+export type HookJSONOutput = SyncHookJSONOutput;
+export type HookCallback = (input: HookInput, toolUseID: string | undefined, options: {
+    signal: AbortSignal;
+}) => Promise<HookJSONOutput>;
+export interface HookCallbackMatcher {
+    matcher?: string;
+    hooks: HookCallback[];
+    timeout?: number;
+    onFailure?: "continue" | "block";
+}
+export type PermissionResult = {
+    behavior: "allow";
+    updatedInput?: Record<string, unknown>;
+} | {
+    behavior: "deny";
+    message: string;
+    interrupt?: boolean;
+};
+export type CanUseTool = (toolName: string, input: Record<string, unknown>, options: {
+    signal: AbortSignal;
+    toolUseID: string;
+    requestId: string;
+    agentID?: string;
+}) => Promise<PermissionResult | null>;
+export interface AgentDefinition {
+    description: string;
+    prompt: string;
+    tools?: string[];
+    disallowedTools?: string[];
+    model?: string;
+    maxTurns?: number;
+    effort?: Effort;
+    skills?: string[];
+}
+export interface SdkPluginConfig {
+    type: "local";
+    path: string;
+}
+export interface ZpiOptions {
+    requestOptions?: import("../../ai/src/index.js").SimpleStreamOptions | (() => import("../../ai/src/index.js").SimpleStreamOptions);
+    modelRuntime?: ModelRuntime;
+    providers?: Record<string, ProviderConfigInput>;
+    fetch?: typeof fetch;
+    agentDir?: string;
+    plugins?: readonly SessionPlugin[];
+    customTools?: readonly ToolDefinition[];
+    resourceLoader?: ResourceLoader;
+    /** Advanced host-owned session; preserves indexed history and native tool/plugin contracts. */
+    session?: AgentSession;
+    sessionManager?: SessionManager;
+    input?: {
+        parsed: ParsedInput;
+        context: InputContext;
+    };
+}
+export interface Options {
+    cwd?: string;
+    model?: string;
+    abortController?: AbortController;
+    env?: Record<string, string | undefined>;
+    tools?: string[] | {
+        type: "preset";
+        preset: "claude_code";
+    };
+    allowedTools?: string[];
+    disallowedTools?: string[];
+    canUseTool?: CanUseTool;
+    systemPrompt?: string | string[] | {
+        type: "custom";
+        prompt: string | string[];
+    } | {
+        type: "preset";
+        preset: "claude_code";
+        append?: string;
+    };
+    thinking?: ThinkingConfig;
+    effort?: Effort;
+    maxThinkingTokens?: number;
+    maxTurns?: number;
+    maxBudgetUsd?: number;
+    includePartialMessages?: boolean;
+    forwardSubagentText?: boolean;
+    includeHookEvents?: boolean;
+    hooks?: Partial<Record<HookEvent, HookCallbackMatcher[]>>;
+    persistSession?: boolean;
+    resume?: string;
+    continue?: boolean;
+    forkSession?: boolean;
+    resumeSessionAt?: string;
+    sessionId?: string;
+    title?: string;
+    outputFormat?: {
+        type: "json_schema";
+        schema: Record<string, unknown>;
+    };
+    agents?: Record<string, AgentDefinition>;
+    agent?: string;
+    plugins?: SdkPluginConfig[];
+    skills?: string[] | "all";
+    settingSources?: ("user" | "project" | "local")[];
+    enableFileCheckpointing?: boolean;
+    zpi?: ZpiOptions;
+}
+export interface SDKHookResponseMessage {
+    type: "system";
+    subtype: "hook_response";
+    uuid: string;
+    session_id: string;
+    hook_id: string;
+    hook_name: string;
+    hook_event: string;
+    output: string;
+    stdout: string;
+    stderr: string;
+    exit_code: number;
+    outcome: "success" | "error" | "cancelled";
+}
+export interface SDKCompactBoundaryMessage {
+    type: "system";
+    subtype: "compact_boundary";
+    uuid: string;
+    session_id: string;
+    compact_metadata: {
+        trigger: "manual" | "auto";
+        pre_tokens: number;
+    };
+}
+export type SDKMessage = SDKUserMessage | SDKAssistantMessage | SDKSystemMessage | SDKPartialAssistantMessage | SDKResultMessage | SDKHookResponseMessage | SDKCompactBoundaryMessage;
+export interface SlashCommand {
+    name: string;
+    description: string;
+    argumentHint: string;
+}
+export interface ModelInfo {
+    value: string;
+    displayName: string;
+    description: string;
+    supportsEffort?: boolean;
+    supportedEffortLevels?: Effort[];
+}
+export interface AgentInfo {
+    name: string;
+    description: string;
+    model?: string;
+}
+export interface SDKControlInitializeResponse {
+    commands: SlashCommand[];
+    models: ModelInfo[];
+    agents: AgentInfo[];
+    account: {
+        apiKeySource: string;
+    };
+}
+export interface RewindFilesResult {
+    canRewind: boolean;
+    error?: string;
+    filesChanged?: string[];
+    insertions?: number;
+    deletions?: number;
+}
+export interface SDKControlInterruptResponse {
+    still_queued: string[];
+    cancelled?: string[];
+}
+export interface Query extends AsyncGenerator<SDKMessage, void> {
+    interrupt(): Promise<SDKControlInterruptResponse | undefined>;
+    setModel(model?: string): Promise<void>;
+    setMaxThinkingTokens(maxThinkingTokens: number | null): Promise<void>;
+    supportedCommands(): Promise<SlashCommand[]>;
+    supportedModels(): Promise<ModelInfo[]>;
+    supportedAgents(): Promise<AgentInfo[]>;
+    initializationResult(): Promise<SDKControlInitializeResponse>;
+    rewindFiles(userMessageId: string, options?: {
+        dryRun?: boolean;
+    }): Promise<RewindFilesResult>;
+    close(): void;
+}
+export {};

package/dist/types/ai/src/api/anthropic-messages.d.ts

@@ -0,0 +1,70 @@
+import Anthropic from "@anthropic-ai/sdk";
+import type { SimpleStreamOptions, StreamFunction, StreamOptions } from "../types.js";
+export type AnthropicEffort = "low" | "medium" | "high" | "xhigh" | "max";
+export type AnthropicThinkingDisplay = "summarized" | "omitted";
+export interface AnthropicOptions extends StreamOptions {
+    /**
+     * Enable extended thinking.
+     * For adaptive thinking models: the model decides when/how much to think.
+     * For older models: uses budget-based thinking with thinkingBudgetTokens.
+     * Default: undefined (thinking is omitted unless `streamSimple()` maps
+     * a simple reasoning level to this option, or callers set it explicitly).
+     */
+    thinkingEnabled?: boolean;
+    /**
+     * Token budget for extended thinking (older models only).
+     * Ignored for adaptive thinking models.
+     * Default: 1024 when `thinkingEnabled` is true and no budget is provided.
+     */
+    thinkingBudgetTokens?: number;
+    /**
+     * Effort level for adaptive thinking models.
+     * Controls how much thinking Claude allocates:
+     * - "max": Always thinks with no constraints (Opus 4.6 only)
+     * - "xhigh": Highest reasoning level (Opus 4.7+, Fable 5)
+     * - "high": Always thinks, deep reasoning
+     * - "medium": Moderate thinking, may skip for simple queries
+     * - "low": Minimal thinking, skips for simple tasks
+     * Ignored for older models.
+     * Default: omitted unless `streamSimple()` maps a simple reasoning
+     * level to this option.
+     */
+    effort?: AnthropicEffort;
+    /**
+     * Controls how thinking content is returned in API responses.
+     * - "summarized": Thinking blocks contain summarized thinking text.
+     * - "omitted": Thinking blocks return an empty thinking field; the encrypted
+     *   signature still travels back for multi-turn continuity. Use for faster
+     *   time-to-first-text-token when your UI does not surface thinking.
+     *
+     * Note: Anthropic's API default for Claude Opus 4.7 and Claude Mythos Preview
+     * is "omitted". We default to "summarized" here to keep behavior consistent
+     * with older Claude 4 models. Set this explicitly to "omitted" to opt in.
+     * Default: "summarized" when thinking is enabled.
+     */
+    thinkingDisplay?: AnthropicThinkingDisplay;
+    /**
+     * Whether to request the interleaved thinking beta header for non-adaptive
+     * thinking models. Adaptive thinking models have interleaved thinking built in,
+     * so the header is skipped for them regardless of this setting.
+     * Default: true.
+     */
+    interleavedThinking?: boolean;
+    /**
+     * Anthropic tool choice behavior. String values map to Anthropic's built-in
+     * choices; `{ type: "tool", name }` forces a specific tool.
+     * Default: omitted (Anthropic default behavior, currently equivalent to auto).
+     */
+    toolChoice?: "auto" | "any" | "none" | {
+        type: "tool";
+        name: string;
+    };
+    /**
+     * Pre-built Anthropic client instance. When provided, skips internal client
+     * construction entirely. Use this to inject alternative SDK clients such as
+     * `AnthropicVertex` that shares the same messaging API.
+     */
+    client?: Anthropic;
+}
+export declare const stream: StreamFunction<"anthropic-messages", AnthropicOptions>;
+export declare const streamSimple: StreamFunction<"anthropic-messages", SimpleStreamOptions>;

package/dist/types/ai/src/api/constrained-sampling.d.ts

@@ -0,0 +1,5 @@
+import type { Tool } from "../types.js";
+/** Convert a tool schema to the strict subset expected by provider constrained sampling. */
+export declare function makeStrictJsonSchema(schema: Tool["parameters"]): Record<string, unknown>;
+export declare function getJsonSchemaToolParameters(tool: Tool, strict: boolean | undefined): Tool["parameters"];
+export declare function resolveJsonSchemaStrictSampling(tool: Tool, supportsStrictMode: boolean): boolean | undefined;

package/dist/types/ai/src/api/github-copilot-headers.d.ts

@@ -0,0 +1,7 @@
+import type { Message } from "../types.js";
+export declare function inferCopilotInitiator(messages: Message[]): "user" | "agent";
+export declare function hasCopilotVisionInput(messages: Message[]): boolean;
+export declare function buildCopilotDynamicHeaders(params: {
+    messages: Message[];
+    hasImages: boolean;
+}): Record<string, string>;

package/dist/types/ai/src/api/openai-completions.d.ts

@@ -0,0 +1,10 @@
+import type { ChatCompletionCreateParamsStreaming } from "openai/resources/chat/completions";
+import type { Model, SimpleStreamOptions, StreamOptions, TranscriptContext } from "../types.js";
+import { MeasuredAssistantStream } from "../utils/model-performance.js";
+export interface OpenAICompletionsOptions extends StreamOptions {
+    reasoningEffort?: string;
+    reasoning?: SimpleStreamOptions["reasoning"];
+    toolChoice?: ChatCompletionCreateParamsStreaming["tool_choice"];
+}
+export declare function streamSimple(model: Model, context: TranscriptContext, options?: SimpleStreamOptions): MeasuredAssistantStream;
+export declare function stream(model: Model, context: TranscriptContext, options?: OpenAICompletionsOptions): MeasuredAssistantStream;

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

@@ -0,0 +1,5 @@
+import type { ResponseInput } from "openai/resources/responses/responses";
+import type { Model, SimpleStreamOptions, TranscriptContext } from "../types.js";
+import { MeasuredAssistantStream } from "../utils/model-performance.js";
+export declare function responsesInput(model: Model, context: TranscriptContext): ResponseInput;
+export declare function streamSimple(model: Model, context: TranscriptContext, options?: SimpleStreamOptions): MeasuredAssistantStream;

package/dist/types/ai/src/api/responses-cache.d.ts

@@ -0,0 +1,6 @@
+import type { ResponseCreateParamsStreaming, ResponseInput } from "openai/resources/responses/responses";
+import type { Model, StreamOptions } from "../types.js";
+/** OpenAI's cache controls differ before and after GPT-5.6; unknown gateway aliases keep their defaults. */
+export declare function responsesCache(model: Model, options: StreamOptions, input: ResponseInput): {
+    input: ResponseInput;
+} & Pick<ResponseCreateParamsStreaming, "prompt_cache_key" | "prompt_cache_options" | "prompt_cache_retention">;

package/dist/types/ai/src/api/responses-events.d.ts

@@ -0,0 +1,3 @@
+import type { ResponseStreamEvent } from "openai/resources/responses/responses";
+/** Some Responses-compatible gateways ignore stream:true and return a complete JSON response. */
+export declare function responsesEvents(stream: AsyncIterable<ResponseStreamEvent>, response: Response): AsyncIterable<ResponseStreamEvent>;

package/dist/types/ai/src/api/responses-session.d.ts

@@ -0,0 +1,56 @@
+import type OpenAI from "openai";
+import type { ResponseStreamEvent } from "openai/resources/responses/responses";
+import type { Model, StreamOptions } from "../types.js";
+type Payload = Record<string, unknown> & {
+    input: unknown[];
+};
+type FailureReason = "connection_limit" | "previous_response_not_found" | "invalid_previous_response" | "closed_connection" | "transport" | "request_error" | "observer_error" | "aborted" | "disposed";
+export interface ResponsesSessionStats {
+    connectionsCreated: number;
+    connectionsReused: number;
+    websocketRequests: number;
+    warmupRequests: number;
+    fullContextRequests: number;
+    deltaRequests: number;
+    reconnects: number;
+    websocketFailures: number;
+    httpRequests: number;
+    httpFallbacks: number;
+    lastInputItems: number;
+    lastFullInputItems: number;
+}
+export interface ResponsesSessionDiagnostic {
+    event: "request" | "reconnect" | "fallback" | "complete" | "error";
+    transport: "websocket" | "http";
+    warmup: boolean;
+    reason?: FailureReason;
+    stats: ResponsesSessionStats;
+}
+export interface ResponsesSessionOptions {
+    /** Resolve a proxy URL, or undefined for a direct connection. Hosts can supply their system/PAC resolver. */
+    resolveProxy?: (url: string) => Promise<string | undefined>;
+    /** Local counters only: no credentials, prompts, response IDs, or server error bodies. */
+    onDiagnostic?: (diagnostic: ResponsesSessionDiagnostic) => void;
+}
+export declare function supportsResponsesWebSocket(model: Model): boolean;
+/** One conversation, one authenticated socket. Nothing here is persisted in the transcript. */
+export declare class ResponsesSession {
+    private socket?;
+    private identity?;
+    private previous?;
+    private idle?;
+    private openedAt;
+    private httpUntil;
+    private lifecycle;
+    private tail;
+    private options;
+    private stats;
+    constructor(options?: ResponsesSessionOptions);
+    get diagnostics(): ResponsesSessionStats;
+    private get disposed();
+    private report;
+    dispose(): void;
+    private disconnect;
+    events(client: OpenAI, model: Model, payload: Payload, options: StreamOptions, http: () => Promise<AsyncIterable<ResponseStreamEvent>>, start: () => void): AsyncGenerator<ResponseStreamEvent>;
+}
+export {};

package/dist/types/ai/src/api/simple-options.d.ts

@@ -0,0 +1,14 @@
+import type { Api, Model, SimpleStreamOptions, StreamOptions, ThinkingBudgets, ThinkingLevel, TranscriptContext } from "../types.js";
+export declare function clampMaxTokensToContext(model: Model<Api>, context: TranscriptContext, maxTokens: number): number;
+export declare function buildBaseOptions(model: Model<Api>, context: TranscriptContext, options?: SimpleStreamOptions, apiKey?: string): StreamOptions;
+/** Tokens always left for the answer when a thinking budget shares the response ceiling. */
+export declare const MIN_ANSWER_TOKENS = 1024;
+export declare const DEFAULT_THINKING_BUDGETS: ThinkingBudgets;
+export declare function clampReasoning(effort: ThinkingLevel | undefined): Exclude<ThinkingLevel, "xhigh" | "max"> | undefined;
+export declare function thinkingBudgetForLevel(reasoningLevel: ThinkingLevel, customBudgets?: ThinkingBudgets): number;
+/** Cap a thinking budget so at least MIN_ANSWER_TOKENS remain under a shared response ceiling. */
+export declare function clampThinkingBudgetToAnswerRoom(thinkingBudget: number, ceiling: number): number;
+export declare function adjustMaxTokensForThinking(baseMaxTokens: number | undefined, modelMaxTokens: number, reasoningLevel: ThinkingLevel, customBudgets?: ThinkingBudgets): {
+    maxTokens: number;
+    thinkingBudget: number;
+};

package/dist/types/ai/src/api/transform-messages.d.ts

@@ -0,0 +1,3 @@
+import type { Message, Model } from "../types.js";
+/** Replay a portable local transcript; provider signatures only belong to their original model. */
+export declare function transformMessages(messages: readonly Message[], model: Model, normalizeId?: (id: string) => string): Message[];

package/dist/types/ai/src/auth/openai-chatgpt.d.ts

@@ -0,0 +1,32 @@
+export interface ChatGPTCredential {
+    access: string;
+    refresh: string;
+    expires: number;
+    clientId: string;
+    subject: string;
+    email?: string;
+    idToken: string;
+    /** Rotated tokens are durable but cannot be used until this identity is verified. */
+    identityPending?: boolean;
+    scopes: string[];
+}
+export declare function isChatGPTCredential(value: unknown): value is ChatGPTCredential;
+export declare function verifyChatGPTIdentity(idToken: string, clientId: string, nonce: string | undefined, fetcher: typeof fetch): Promise<{
+    subject: string;
+    email?: string | undefined;
+}>;
+export declare function refreshChatGPTCredential(credential: ChatGPTCredential, fetcher?: typeof fetch, saveRotation?: (credential: ChatGPTCredential) => void): Promise<ChatGPTCredential>;
+export declare function verifyRefreshedChatGPTCredential(credential: ChatGPTCredential, fetcher?: typeof fetch): Promise<ChatGPTCredential>;
+export declare function revokeChatGPTCredential(credential: ChatGPTCredential, fetcher?: typeof fetch): Promise<void>;
+export interface ChatGPTLogin {
+    url: string;
+    wait(): Promise<ChatGPTCredential>;
+    submitCallback(url: string): void;
+    cancel(): void;
+}
+export declare function beginChatGPTLogin(options: {
+    hostId: string;
+    credential?: ChatGPTCredential;
+    fetch?: typeof fetch;
+    timeoutMs?: number;
+}): Promise<ChatGPTLogin>;

package/dist/types/ai/src/index.d.ts

@@ -0,0 +1,20 @@
+export type { AnthropicEffort, AnthropicOptions, AnthropicThinkingDisplay, } from "./api/anthropic-messages.js";
+export type { ResponsesSessionDiagnostic, ResponsesSessionOptions, ResponsesSessionStats, } from "./api/responses-session.js";
+export type { ModelDiscoveryInput, ModelDiscoveryResult } from "./providers/discovery.js";
+export { fetchProviderModels } from "./providers/discovery.js";
+export type { DiscoveredModel, ProviderPresetId } from "./providers/registry.js";
+export { discoverProviderCredentials, getProviderPreset, isLegacyOpenAIModel, presetModels, providerApi, providerApis, providerBaseUrl, providerPresets, usesChatGPTAuth, } from "./providers/registry.js";
+export { streamSimple } from "./stream.js";
+export type * from "./types.js";
+export { anthropicMessagesCompatKeys, openAICompletionsCompatKeys } from "./types.js";
+export { abortable } from "./utils/abort.js";
+export { calculateContextTokens, estimateMessageTokens } from "./utils/estimate.js";
+export { AssistantMessageEventStream, createAssistantMessageEventStream } from "./utils/event-stream.js";
+export { guardModelStream } from "./utils/guard-model-stream.js";
+export * from "./utils/media-policy.js";
+export { modelFailure } from "./utils/model-retry.js";
+export { isContextOverflow as isContextOverflowMessage, isModelContextExceededError, isModelContextExceededMessage, isModelMediaTooLargeError, isModelMediaTooLargeMessage, isRecoverableLength, } from "./utils/overflow.js";
+export { canControlThinking, clampThinkingLevel, defaultThinkingLevel, editableReasoningConfig, reasoningParameters, thinkingChoices, validateReasoningConfig, validateThinkingMap, } from "./utils/reasoning.js";
+export * from "./utils/retry.js";
+export { DEFAULT_MODEL_FIRST_RESPONSE_TIMEOUT_MS, DEFAULT_MODEL_STREAM_IDLE_TIMEOUT_MS, ModelRequestRetryError, } from "./utils/stream-idle-timeout.js";
+export { assertSupportedOptions, contentText, emptyAssistant, getCurrentSystemPrompt, getCurrentTools, isJsonObject, isJsonValue, normalizeContext, toToolDeclaration, } from "./utils/transcript.js";