@agent-api/sdk 1.0.0

package/dist/pagination.js

@@ -0,0 +1,38 @@
+export class Page {
+    fetchPage;
+    params;
+    data;
+    hasMore;
+    nextPageToken;
+    constructor(fetchPage, params, data, hasMore, nextPageToken) {
+        this.fetchPage = fetchPage;
+        this.params = params;
+        this.data = data;
+        this.hasMore = hasMore;
+        this.nextPageToken = nextPageToken;
+    }
+    [Symbol.asyncIterator]() {
+        return this.iterateAll()[Symbol.asyncIterator]();
+    }
+    async getNextPage() {
+        if (!this.hasMore || !this.nextPageToken) {
+            return null;
+        }
+        const nextParams = { ...this.params, page_token: this.nextPageToken };
+        const result = await this.fetchPage(nextParams);
+        return new Page(this.fetchPage, nextParams, result.data, result.has_more, result.next_page_token);
+    }
+    async *iterateAll() {
+        let page = this;
+        while (page) {
+            for (const item of page.data) {
+                yield item;
+            }
+            page = await page.getNextPage();
+        }
+    }
+}
+export async function collectPage(fetchPage, params) {
+    const result = await fetchPage(params);
+    return new Page(fetchPage, params, result.data, result.has_more, result.next_page_token);
+}

package/dist/resources/models.d.ts

@@ -0,0 +1,8 @@
+import type { HTTPClient } from "../internal/http.js";
+import type { RequestOptions } from "../types/common.js";
+import type { ListModelsResponse } from "../types/catalog.js";
+export declare class ModelsResource {
+    private readonly http;
+    constructor(http: HTTPClient);
+    list(options?: RequestOptions): Promise<ListModelsResponse>;
+}

package/dist/resources/models.js

@@ -0,0 +1,9 @@
+export class ModelsResource {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    list(options) {
+        return this.http.request("GET", "/v1/models", undefined, options);
+    }
+}

package/dist/resources/presets.d.ts

@@ -0,0 +1,8 @@
+import type { HTTPClient } from "../internal/http.js";
+import type { RequestOptions } from "../types/common.js";
+import type { ListPresetsResponse } from "../types/catalog.js";
+export declare class PresetsResource {
+    private readonly http;
+    constructor(http: HTTPClient);
+    list(options?: RequestOptions): Promise<ListPresetsResponse>;
+}

package/dist/resources/presets.js

@@ -0,0 +1,9 @@
+export class PresetsResource {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    list(options) {
+        return this.http.request("GET", "/v1/presets", undefined, options);
+    }
+}

package/dist/resources/responses.d.ts

@@ -0,0 +1,19 @@
+import type { HTTPClient } from "../internal/http.js";
+import { Page } from "../pagination.js";
+import type { RequestOptions } from "../types/common.js";
+import type { AgentResponse, CancelResponse, ListChildrenResponse, ListEventsParams, ListEventsResponse, ListResponsesParams, ListResponsesResponse, ResponseCreateParamsNonStreaming, ResponseCreateParamsStreaming, ResponseListItem } from "../types/responses.js";
+import type { ResponseStreamEvent } from "../types/streaming.js";
+export declare class ResponsesResource {
+    private readonly http;
+    private readonly path;
+    constructor(http: HTTPClient, path?: string);
+    create(params: ResponseCreateParamsNonStreaming, options?: RequestOptions): Promise<AgentResponse>;
+    create(params: ResponseCreateParamsStreaming, options?: RequestOptions): Promise<AsyncIterable<ResponseStreamEvent>>;
+    list(params?: ListResponsesParams, options?: RequestOptions): Promise<ListResponsesResponse>;
+    listPage(params?: ListResponsesParams, options?: RequestOptions): Promise<Page<ResponseListItem, ListResponsesParams>>;
+    listIterator(params?: ListResponsesParams, options?: RequestOptions): AsyncIterable<ResponseListItem>;
+    retrieve(responseID: string, options?: RequestOptions): Promise<AgentResponse>;
+    cancel(responseID: string, options?: RequestOptions): Promise<CancelResponse>;
+    listChildren(responseID: string, options?: RequestOptions): Promise<ListChildrenResponse>;
+    listEvents(responseID: string, params?: ListEventsParams, options?: RequestOptions): Promise<ListEventsResponse>;
+}

package/dist/resources/responses.js

@@ -0,0 +1,49 @@
+import { addOutputText } from "../internal/output-text.js";
+import { buildQuery } from "../internal/query.js";
+import { collectPage } from "../pagination.js";
+export class ResponsesResource {
+    http;
+    path;
+    constructor(http, path = "/v1/responses") {
+        this.http = http;
+        this.path = path;
+    }
+    create(params, options) {
+        if (params.stream) {
+            return this.http.stream(this.path, params, options);
+        }
+        return this.http.request("POST", this.path, params, options).then(addOutputText);
+    }
+    list(params = {}, options) {
+        return this.http.request("GET", `${this.path}${buildQuery({ limit: params.limit, page_token: params.page_token })}`, undefined, options);
+    }
+    async listPage(params = {}, options) {
+        return collectPage((pageParams) => this.list(pageParams, options), params);
+    }
+    listIterator(params = {}, options) {
+        const self = this;
+        return {
+            async *[Symbol.asyncIterator]() {
+                const page = await self.listPage(params, options);
+                yield* page.iterateAll();
+            },
+        };
+    }
+    retrieve(responseID, options) {
+        return this.http
+            .request("GET", `${this.path}/${encodeURIComponent(responseID)}`, undefined, options)
+            .then(addOutputText);
+    }
+    cancel(responseID, options) {
+        return this.http.request("POST", `${this.path}/${encodeURIComponent(responseID)}/cancel`, undefined, options);
+    }
+    listChildren(responseID, options) {
+        return this.http.request("GET", `${this.path}/${encodeURIComponent(responseID)}/children`, undefined, options);
+    }
+    listEvents(responseID, params = {}, options) {
+        return this.http.request("GET", `${this.path}/${encodeURIComponent(responseID)}/events${buildQuery({
+            after_sequence: params.after_sequence,
+            view: params.view,
+        })}`, undefined, options);
+    }
+}

package/dist/resources/tools.d.ts

@@ -0,0 +1,8 @@
+import type { HTTPClient } from "../internal/http.js";
+import type { RequestOptions } from "../types/common.js";
+import type { ListToolsResponse } from "../types/tools.js";
+export declare class ToolsResource {
+    private readonly http;
+    constructor(http: HTTPClient);
+    list(options?: RequestOptions): Promise<ListToolsResponse>;
+}

package/dist/resources/tools.js

@@ -0,0 +1,9 @@
+export class ToolsResource {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    list(options) {
+        return this.http.request("GET", "/v1/tools", undefined, options);
+    }
+}

package/dist/streaming.d.ts

@@ -0,0 +1 @@
+export declare function parseSSE<T>(response: Response): AsyncIterable<T>;

package/dist/streaming.js

@@ -0,0 +1,39 @@
+import { APIConnectionError } from "./errors.js";
+export async function* parseSSE(response) {
+    if (!response.body) {
+        throw new APIConnectionError("Streaming response did not include a body");
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    for (;;) {
+        const { value, done } = await reader.read();
+        if (done) {
+            break;
+        }
+        buffer += decoder.decode(value, { stream: true });
+        const parts = buffer.split(/\r?\n\r?\n/);
+        buffer = parts.pop() ?? "";
+        for (const part of parts) {
+            const event = parseSSEBlock(part);
+            if (event !== undefined) {
+                yield event;
+            }
+        }
+    }
+    const finalEvent = parseSSEBlock(buffer);
+    if (finalEvent !== undefined) {
+        yield finalEvent;
+    }
+}
+function parseSSEBlock(block) {
+    const data = block
+        .split(/\r?\n/)
+        .filter((line) => line.startsWith("data:"))
+        .map((line) => line.slice(5).trimStart())
+        .join("\n");
+    if (!data || data === "[DONE]") {
+        return undefined;
+    }
+    return JSON.parse(data);
+}

package/dist/types/catalog.d.ts

@@ -0,0 +1,40 @@
+import type { AgentCapabilityPreference } from "./common.js";
+export interface ModelCapabilities {
+    provider?: string;
+    supports_streaming?: boolean;
+    supports_tools?: boolean;
+    supports_json_schema?: boolean;
+    supports_reasoning?: boolean;
+    context_window?: number;
+    pricing?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+}
+export interface Model {
+    id: string;
+    object: "model";
+    owned_by: string;
+    capabilities?: ModelCapabilities;
+}
+export interface ListModelsResponse {
+    object: "list";
+    data: Model[];
+}
+export interface PresetPolicy {
+    plan_mode_preference?: AgentCapabilityPreference;
+    sub_agent_preference?: AgentCapabilityPreference;
+    allowed_tools?: string[];
+    max_steps?: number;
+}
+export interface Preset {
+    preset: string;
+    prompt_version?: string;
+    preset_metadata?: Record<string, unknown>;
+    policy?: PresetPolicy;
+    max_output_tokens?: number;
+    default_model?: string;
+    model_chain?: string[];
+}
+export interface ListPresetsResponse {
+    object: "list";
+    data: Preset[];
+}

package/dist/types/catalog.js

@@ -0,0 +1 @@
+export {};

package/dist/types/common.d.ts

@@ -0,0 +1,52 @@
+export type JSONPrimitive = string | number | boolean | null;
+export type JSONValue = JSONPrimitive | JSONValue[] | {
+    [key: string]: JSONValue;
+};
+export type AgentCapabilityPreference = "off" | "auto" | "preferred" | "required";
+export interface ClientOptions {
+    apiKey?: string;
+    baseURL?: string;
+    /** Default request timeout in milliseconds (non-streaming). */
+    timeout?: number;
+    /** Timeout for streaming agent runs in milliseconds. */
+    streamTimeout?: number;
+    /** Maximum number of automatic retries for retryable failures. Default 2. */
+    maxRetries?: number;
+    fetch?: typeof fetch;
+    defaultHeaders?: Record<string, string>;
+}
+export interface RequestOptions {
+    headers?: Record<string, string>;
+    timeout?: number;
+    /** Override automatic retries for this request. */
+    maxRetries?: number;
+}
+export interface RetryConfig {
+    maxRetries: number;
+}
+export interface ErrorInfo {
+    message: string;
+    type?: string;
+    code?: string;
+}
+export interface Usage {
+    input_tokens?: number;
+    output_tokens?: number;
+    total_tokens?: number;
+    input_tokens_details?: Record<string, number>;
+    output_tokens_details?: Record<string, number>;
+    tool_calls_details?: Record<string, {
+        invocation?: number;
+    }>;
+    cost?: {
+        currency?: string;
+        input_cost?: number;
+        output_cost?: number;
+        tool_calls_cost?: number;
+        cache_read_cost?: number;
+        cache_creation_cost?: number;
+        total_cost?: number;
+    };
+}
+export type ResponseStatus = "completed" | "failed" | "in_progress" | "cancelled" | "requires_action";
+export type OutputItemStatus = "completed" | "failed" | "in_progress";

package/dist/types/common.js

@@ -0,0 +1 @@
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./common.js";
+export * from "./input.js";
+export * from "./tools.js";
+export * from "./responses.js";
+export * from "./streaming.js";
+export * from "./catalog.js";

package/dist/types/index.js

@@ -0,0 +1,6 @@
+export * from "./common.js";
+export * from "./input.js";
+export * from "./tools.js";
+export * from "./responses.js";
+export * from "./streaming.js";
+export * from "./catalog.js";

package/dist/types/input.d.ts

@@ -0,0 +1,52 @@
+export interface Annotation {
+    type?: string;
+    title?: string;
+    url?: string;
+    start_index?: number;
+    end_index?: number;
+}
+export interface ContentPart {
+    type: "input_text" | "output_text" | "input_image";
+    text?: string;
+    image_url?: string;
+    annotations?: Annotation[];
+    logprobs?: unknown[];
+}
+export interface InputMessage {
+    type: "message";
+    role: "system" | "developer" | "user" | "assistant";
+    content: string | ContentPart[];
+}
+export interface FunctionCallInput {
+    type: "function_call";
+    call_id: string;
+    name: string;
+    arguments: string;
+    thought_signature?: string;
+}
+export interface FunctionCallOutputInput {
+    type: "function_call_output";
+    call_id: string;
+    output: string;
+    name?: string;
+    thought_signature?: string;
+}
+export type InputItem = InputMessage | FunctionCallInput | FunctionCallOutputInput;
+export type Input = string | InputItem[];
+export interface ReasoningConfig {
+    effort?: "low" | "medium" | "high";
+}
+export interface ResponseFormat {
+    type: "json_schema";
+    json_schema?: {
+        name: string;
+        description?: string;
+        schema: Record<string, unknown>;
+        strict?: boolean;
+    };
+}
+export interface MemoryOptions {
+    enabled?: boolean;
+    read?: boolean;
+    write?: boolean;
+}

package/dist/types/input.js

@@ -0,0 +1 @@
+export {};

package/dist/types/responses.d.ts

@@ -0,0 +1,151 @@
+import type { AgentCapabilityPreference, ErrorInfo, OutputItemStatus, ResponseStatus, Usage } from "./common.js";
+import type { ContentPart, Input, MemoryOptions, ReasoningConfig, ResponseFormat } from "./input.js";
+import type { Tool } from "./tools.js";
+export interface ResponseCreateParamsBase {
+    input: Input;
+    instructions?: string;
+    language_preference?: string;
+    model?: string;
+    models?: string[];
+    preset?: "fast-search" | "pro-search" | "deep-research" | "advanced-deep-research" | string;
+    max_output_tokens?: number;
+    max_steps?: number;
+    reasoning?: ReasoningConfig;
+    response_format?: ResponseFormat;
+    tools?: Tool[];
+    tool_choice?: "auto" | "none" | "required" | Record<string, unknown>;
+    parallel_tool_calls?: boolean;
+    metadata?: Record<string, unknown>;
+    store?: boolean;
+    previous_response_id?: string;
+    prompt_cache_key?: string;
+    memory?: MemoryOptions;
+    plan_mode_preference?: AgentCapabilityPreference;
+    sub_agent_preference?: AgentCapabilityPreference;
+    stream?: boolean;
+}
+export interface ResponseCreateParamsNonStreaming extends ResponseCreateParamsBase {
+    stream?: false;
+}
+export interface ResponseCreateParamsStreaming extends ResponseCreateParamsBase {
+    stream: true;
+}
+export type ResponseCreateParams = ResponseCreateParamsNonStreaming | ResponseCreateParamsStreaming;
+export interface ToolInvocationResult {
+    id?: string;
+    tool_call_id?: string;
+    tool_name?: string;
+    status?: string;
+    error?: ErrorInfo | null;
+    metadata?: Record<string, unknown>;
+    response_summary?: string;
+    response_summary_mime_type?: string;
+}
+export interface MessageOutputItem {
+    type: "message";
+    id: string;
+    status: OutputItemStatus;
+    role: "assistant";
+    content: ContentPart[];
+}
+export interface SearchResult {
+    id: number;
+    title: string;
+    url: string;
+    snippet: string;
+    source?: string;
+    date?: string;
+    last_updated?: string;
+}
+export interface SearchResultsOutputItem {
+    type: "search_results";
+    queries?: string[];
+    results: SearchResult[];
+}
+export interface URLContent {
+    url: string;
+    title: string;
+    snippet: string;
+}
+export interface FetchURLResultsOutputItem {
+    type: "fetch_url_results";
+    contents: URLContent[];
+}
+export interface FunctionCallOutputItem {
+    type: "function_call";
+    id: string;
+    status: OutputItemStatus;
+    name: string;
+    call_id: string;
+    arguments: string;
+    thought_signature?: string;
+}
+export type OutputItem = MessageOutputItem | SearchResultsOutputItem | FetchURLResultsOutputItem | FunctionCallOutputItem;
+export interface AgentResponse {
+    id: string;
+    object: "response";
+    created_at: number;
+    completed_at?: number | null;
+    status: ResponseStatus;
+    model: string;
+    output: OutputItem[];
+    output_text?: string;
+    usage?: Usage;
+    error?: ErrorInfo | null;
+    metadata?: Record<string, unknown>;
+    instructions?: string | null;
+    tools?: Tool[];
+    tool_choice?: unknown;
+    parallel_tool_calls?: boolean;
+    previous_response_id?: string | null;
+    parent_response_id?: string | null;
+    root_response_id?: string | null;
+    prompt_cache_key?: string | null;
+    store?: boolean;
+    background?: boolean;
+    tool_results?: ToolInvocationResult[];
+    plan?: unknown;
+}
+export interface ResponseListItem {
+    id: string;
+    status: ResponseStatus;
+    created_at: number;
+    completed_at?: number | null;
+    model?: string;
+    preset?: string;
+    input_preview?: string;
+    root_response_id?: string;
+    background?: boolean;
+}
+export interface ListResponsesParams {
+    limit?: number;
+    page_token?: string;
+}
+export interface ListResponsesResponse {
+    object: "list";
+    data: ResponseListItem[];
+    has_more: boolean;
+    next_page_token?: string;
+}
+export interface ResponseChildItem {
+    id: string;
+    status: ResponseStatus;
+    created_at: number;
+    completed_at?: number | null;
+    root_response_id?: string;
+    model?: string;
+}
+export interface ListChildrenResponse {
+    object: "list";
+    data: ResponseChildItem[];
+}
+export interface ListEventsParams {
+    after_sequence?: number;
+    view?: "timeline" | "full";
+}
+export interface ListEventsResponse {
+    data: import("./streaming.js").ResponseStreamEvent[];
+}
+export interface CancelResponse {
+    interrupted: boolean;
+}

package/dist/types/responses.js

@@ -0,0 +1 @@
+export {};

package/dist/types/streaming.d.ts

@@ -0,0 +1,41 @@
+import type { ErrorInfo, Usage } from "./common.js";
+import type { AgentResponse, OutputItem, SearchResult, ToolInvocationResult, URLContent } from "./responses.js";
+export interface ResponseStepEvent {
+    step_id?: string;
+    sequence_number?: number;
+    step_type?: string;
+    step_status?: string;
+}
+export interface ResponseModelCallEvent {
+    step_id?: string;
+    step_index?: number;
+    step_type?: string;
+    attempt?: number;
+    status?: string;
+    provider?: string;
+    model?: string;
+    model_chain?: string[];
+    attempt_count?: number;
+}
+export type ResponseStreamEventType = "response.created" | "response.in_progress" | "response.completed" | "response.failed" | "response.plan.updated" | "response.output_item.added" | "response.output_item.done" | "response.output_text.delta" | "response.output_text.done" | "response.reasoning.started" | "response.reasoning.search_queries" | "response.reasoning.search_results" | "response.reasoning.fetch_url_queries" | "response.reasoning.fetch_url_results" | "response.reasoning.stopped" | "response.tool.invocation.completed" | "response.step.completed" | "response.step.failed" | "response.step.skipped" | "response.model.requested" | "response.model.completed" | "response.model.failed";
+export interface ResponseStreamEvent {
+    type: ResponseStreamEventType;
+    sequence_number: number;
+    response?: AgentResponse;
+    item?: OutputItem;
+    output_index?: number;
+    item_id?: string;
+    content_index?: number;
+    delta?: string;
+    text?: string;
+    queries?: string[];
+    urls?: string[];
+    results?: SearchResult[];
+    contents?: URLContent[];
+    thought?: string;
+    error?: ErrorInfo | null;
+    usage?: Usage;
+    step?: ResponseStepEvent;
+    model_call?: ResponseModelCallEvent;
+    tool_result?: ToolInvocationResult | null;
+}

package/dist/types/streaming.js

@@ -0,0 +1 @@
+export {};

package/dist/types/tools.d.ts

@@ -0,0 +1,44 @@
+export interface WebSearchTool {
+    name: "web_search";
+    type?: "search";
+    max_tokens?: number;
+    max_tokens_per_page?: number;
+}
+export interface SmartWebSearchTool {
+    name: "smart_web_search";
+    type?: "search";
+    max_tokens?: number;
+    max_tokens_per_page?: number;
+}
+export interface FetchURLTool {
+    name: "fetch_url";
+    type?: "url_reader";
+}
+export interface FunctionTool {
+    type: "function";
+    name: string;
+    description?: string;
+    parameters?: Record<string, unknown>;
+    strict?: boolean;
+}
+export interface SkillTool {
+    type: "skill";
+    name: string;
+    version?: string;
+    arguments?: Record<string, unknown>;
+}
+export type Tool = WebSearchTool | SmartWebSearchTool | FetchURLTool | FunctionTool | SkillTool;
+export interface PublicTool {
+    object: "tool";
+    name: string;
+    type?: string;
+    description?: string;
+    parameters?: Record<string, unknown>;
+    max_tokens?: number;
+    max_tokens_per_page?: number;
+    version?: string;
+}
+export interface ListToolsResponse {
+    object: "list";
+    data: PublicTool[];
+}

package/dist/types/tools.js

@@ -0,0 +1 @@
+export {};

package/dist/version.d.ts

@@ -0,0 +1,2 @@
+export declare const VERSION = "1.0.0";
+export declare const USER_AGENT = "@agent-api/sdk/1.0.0";

package/dist/version.js

@@ -0,0 +1,2 @@
+export const VERSION = "1.0.0";
+export const USER_AGENT = `@agent-api/sdk/${VERSION}`;