@opencode-ai/sdk 0.1.0-alpha.14 → 0.1.0-alpha.15

package/src/client.ts

@@ -39,10 +39,10 @@ import {
   FindTextResponse,
 } from './resources/find';
 import {
+  AssistantMessage,
+  AssistantMessagePart,
   FilePart,
   Message,
-  MessagePart,
-  ReasoningPart,
   Session,
   SessionAbortResponse,
   SessionChatParams,
@@ -54,13 +54,14 @@ import {
   SessionResource,
   SessionSummarizeParams,
   SessionSummarizeResponse,
-  SourceURLPart,
   StepStartPart,
   TextPart,
-  ToolCall,
-  ToolInvocationPart,
-  ToolPartialCall,
-  ToolResult,
+  ToolPart,
+  ToolStateCompleted,
+  ToolStateError,
+  ToolStatePending,
+  ToolStateRunning,
+  UserMessagePart,
 } from './resources/session';
 import { type Fetch } from './internal/builtin-types';
 import { HeadersLike, NullableHeaders, buildHeaders } from './internal/headers';
@@ -89,6 +90,8 @@ export interface ClientOptions {
    *
    * Note that request timeouts are retried by default, so in a worst-case scenario you may wait
    * much longer than this timeout before the promise succeeds or fails.
+   *
+   * @unit milliseconds
    */
   timeout?: number | undefined;
   /**
@@ -777,18 +780,19 @@ export declare namespace Opencode {
 
   export {
     SessionResource as SessionResource,
+    type AssistantMessage as AssistantMessage,
+    type AssistantMessagePart as AssistantMessagePart,
     type FilePart as FilePart,
     type Message as Message,
-    type MessagePart as MessagePart,
-    type ReasoningPart as ReasoningPart,
     type Session as Session,
-    type SourceURLPart as SourceURLPart,
     type StepStartPart as StepStartPart,
     type TextPart as TextPart,
-    type ToolCall as ToolCall,
-    type ToolInvocationPart as ToolInvocationPart,
-    type ToolPartialCall as ToolPartialCall,
-    type ToolResult as ToolResult,
+    type ToolPart as ToolPart,
+    type ToolStateCompleted as ToolStateCompleted,
+    type ToolStateError as ToolStateError,
+    type ToolStatePending as ToolStatePending,
+    type ToolStateRunning as ToolStateRunning,
+    type UserMessagePart as UserMessagePart,
     type SessionListResponse as SessionListResponse,
     type SessionDeleteResponse as SessionDeleteResponse,
     type SessionAbortResponse as SessionAbortResponse,

package/src/core/streaming.ts

@@ -5,6 +5,8 @@ import { findDoubleNewlineIndex, LineDecoder } from '../internal/decoders/line';
 import { ReadableStreamToAsyncIterable } from '../internal/shims';
 import { isAbortError } from '../internal/errors';
 import { encodeUTF8 } from '../internal/utils/bytes';
+import { loggerFor } from '../internal/utils/log';
+import type { Opencode } from '../client';
 
 type Bytes = string | ArrayBuffer | Uint8Array | null | undefined;
 
@@ -16,16 +18,24 @@ export type ServerSentEvent = {
 
 export class Stream<Item> implements AsyncIterable<Item> {
   controller: AbortController;
+  #client: Opencode | undefined;
 
   constructor(
     private iterator: () => AsyncIterator<Item>,
     controller: AbortController,
+    client?: Opencode,
   ) {
     this.controller = controller;
+    this.#client = client;
   }
 
-  static fromSSEResponse<Item>(response: Response, controller: AbortController): Stream<Item> {
+  static fromSSEResponse<Item>(
+    response: Response,
+    controller: AbortController,
+    client?: Opencode,
+  ): Stream<Item> {
     let consumed = false;
+    const logger = client ? loggerFor(client) : console;
 
     async function* iterator(): AsyncIterator<Item, any, undefined> {
       if (consumed) {
@@ -38,8 +48,8 @@ export class Stream<Item> implements AsyncIterable<Item> {
           try {
             yield JSON.parse(sse.data);
           } catch (e) {
-            console.error(`Could not parse message into JSON:`, sse.data);
-            console.error(`From chunk:`, sse.raw);
+            logger.error(`Could not parse message into JSON:`, sse.data);
+            logger.error(`From chunk:`, sse.raw);
             throw e;
           }
         }
@@ -54,14 +64,18 @@ export class Stream<Item> implements AsyncIterable<Item> {
       }
     }
 
-    return new Stream(iterator, controller);
+    return new Stream(iterator, controller, client);
   }
 
   /**
    * Generates a Stream from a newline-separated ReadableStream
    * where each item is a JSON value.
    */
-  static fromReadableStream<Item>(readableStream: ReadableStream, controller: AbortController): Stream<Item> {
+  static fromReadableStream<Item>(
+    readableStream: ReadableStream,
+    controller: AbortController,
+    client?: Opencode,
+  ): Stream<Item> {
     let consumed = false;
 
     async function* iterLines(): AsyncGenerator<string, void, unknown> {
@@ -101,7 +115,7 @@ export class Stream<Item> implements AsyncIterable<Item> {
       }
     }
 
-    return new Stream(iterator, controller);
+    return new Stream(iterator, controller, client);
   }
 
   [Symbol.asyncIterator](): AsyncIterator<Item> {
@@ -131,8 +145,8 @@ export class Stream<Item> implements AsyncIterable<Item> {
     };
 
     return [
-      new Stream(() => teeIterator(left), this.controller),
-      new Stream(() => teeIterator(right), this.controller),
+      new Stream(() => teeIterator(left), this.controller, this.#client),
+      new Stream(() => teeIterator(right), this.controller, this.#client),
     ];
   }
 

package/src/internal/parse.ts

@@ -24,10 +24,10 @@ export async function defaultParseResponse<T>(client: Opencode, props: APIRespon
       // that if you set `stream: true` the response type must also be `Stream<T>`
 
       if (props.options.__streamClass) {
-        return props.options.__streamClass.fromSSEResponse(response, props.controller) as any;
+        return props.options.__streamClass.fromSSEResponse(response, props.controller, client) as any;
       }
 
-      return Stream.fromSSEResponse(response, props.controller) as any;
+      return Stream.fromSSEResponse(response, props.controller, client) as any;
     }
 
     // fetch refuses to read the body when the status code is 204.

package/src/internal/request-options.ts

@@ -10,17 +10,70 @@ import { type HeadersLike } from './headers';
 export type FinalRequestOptions = RequestOptions & { method: HTTPMethod; path: string };
 
 export type RequestOptions = {
+  /**
+   * The HTTP method for the request (e.g., 'get', 'post', 'put', 'delete').
+   */
   method?: HTTPMethod;
+
+  /**
+   * The URL path for the request.
+   *
+   * @example "/v1/foo"
+   */
   path?: string;
+
+  /**
+   * Query parameters to include in the request URL.
+   */
   query?: object | undefined | null;
+
+  /**
+   * The request body. Can be a string, JSON object, FormData, or other supported types.
+   */
   body?: unknown;
+
+  /**
+   * HTTP headers to include with the request. Can be a Headers object, plain object, or array of tuples.
+   */
   headers?: HeadersLike;
+
+  /**
+   * The maximum number of times that the client will retry a request in case of a
+   * temporary failure, like a network error or a 5XX error from the server.
+   *
+   * @default 2
+   */
   maxRetries?: number;
+
   stream?: boolean | undefined;
+
+  /**
+   * The maximum amount of time (in milliseconds) that the client should wait for a response
+   * from the server before timing out a single request.
+   *
+   * @unit milliseconds
+   */
   timeout?: number;
+
+  /**
+   * Additional `RequestInit` options to be passed to the underlying `fetch` call.
+   * These options will be merged with the client's default fetch options.
+   */
   fetchOptions?: MergedRequestInit;
+
+  /**
+   * An AbortSignal that can be used to cancel the request.
+   */
   signal?: AbortSignal | undefined | null;
+
+  /**
+   * A unique key for this request to enable idempotency.
+   */
   idempotencyKey?: string;
+
+  /**
+   * Override the default base URL for this specific request.
+   */
   defaultBaseURL?: string | undefined;
 
   __binaryResponse?: boolean | undefined;

package/src/resources/event.ts

@@ -20,8 +20,8 @@ export type EventListResponse =
   | EventListResponse.EventLspClientDiagnostics
   | EventListResponse.EventPermissionUpdated
   | EventListResponse.EventFileEdited
-  | EventListResponse.EventStorageWrite
   | EventListResponse.EventInstallationUpdated
+  | EventListResponse.EventStorageWrite
   | EventListResponse.EventMessageUpdated
   | EventListResponse.EventMessageRemoved
   | EventListResponse.EventMessagePartUpdated
@@ -84,29 +84,29 @@ export namespace EventListResponse {
     }
   }
 
-  export interface EventStorageWrite {
-    properties: EventStorageWrite.Properties;
+  export interface EventInstallationUpdated {
+    properties: EventInstallationUpdated.Properties;
 
-    type: 'storage.write';
+    type: 'installation.updated';
   }
 
-  export namespace EventStorageWrite {
+  export namespace EventInstallationUpdated {
     export interface Properties {
-      key: string;
-
-      content?: unknown;
+      version: string;
     }
   }
 
-  export interface EventInstallationUpdated {
-    properties: EventInstallationUpdated.Properties;
+  export interface EventStorageWrite {
+    properties: EventStorageWrite.Properties;
 
-    type: 'installation.updated';
+    type: 'storage.write';
   }
 
-  export namespace EventInstallationUpdated {
+  export namespace EventStorageWrite {
     export interface Properties {
-      version: string;
+      key: string;
+
+      content?: unknown;
     }
   }
 
@@ -146,7 +146,7 @@ export namespace EventListResponse {
     export interface Properties {
       messageID: string;
 
-      part: SessionAPI.MessagePart;
+      part: SessionAPI.AssistantMessagePart;
 
       sessionID: string;
     }

package/src/resources/index.ts

@@ -25,18 +25,19 @@ export {
 } from './find';
 export {
   SessionResource,
+  type AssistantMessage,
+  type AssistantMessagePart,
   type FilePart,
   type Message,
-  type MessagePart,
-  type ReasoningPart,
   type Session,
-  type SourceURLPart,
   type StepStartPart,
   type TextPart,
-  type ToolCall,
-  type ToolInvocationPart,
-  type ToolPartialCall,
-  type ToolResult,
+  type ToolPart,
+  type ToolStateCompleted,
+  type ToolStateError,
+  type ToolStatePending,
+  type ToolStateRunning,
+  type UserMessagePart,
   type SessionListResponse,
   type SessionDeleteResponse,
   type SessionAbortResponse,

package/src/resources/session.ts

@@ -1,6 +1,7 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 import { APIResource } from '../core/resource';
+import * as SessionAPI from './session';
 import * as Shared from './shared';
 import { APIPromise } from '../core/api-promise';
 import { RequestOptions } from '../internal/request-options';
@@ -38,7 +39,7 @@ export class SessionResource extends APIResource {
   /**
    * Create and send a new message to a session
    */
-  chat(id: string, body: SessionChatParams, options?: RequestOptions): APIPromise<Message> {
+  chat(id: string, body: SessionChatParams, options?: RequestOptions): APIPromise<AssistantMessage> {
     return this._client.post(path`/session/${id}/message`, { body, ...options });
   }
 
@@ -82,132 +83,106 @@ export class SessionResource extends APIResource {
   }
 }
 
-export interface FilePart {
-  mediaType: string;
+export interface AssistantMessage {
+  id: string;
 
-  type: 'file';
+  cost: number;
 
-  url: string;
+  modelID: string;
 
-  filename?: string;
-}
+  parts: Array<AssistantMessagePart>;
 
-export interface Message {
-  id: string;
+  path: AssistantMessage.Path;
 
-  metadata: Message.Metadata;
+  providerID: string;
 
-  parts: Array<MessagePart>;
+  role: 'assistant';
 
-  role: 'user' | 'assistant';
-}
+  sessionID: string;
 
-export namespace Message {
-  export interface Metadata {
-    sessionID: string;
+  system: Array<string>;
 
-    time: Metadata.Time;
+  time: AssistantMessage.Time;
 
-    tool: { [key: string]: Metadata.Tool };
+  tokens: AssistantMessage.Tokens;
 
-    assistant?: Metadata.Assistant;
+  error?: Shared.ProviderAuthError | Shared.UnknownError | AssistantMessage.MessageOutputLengthError;
 
-    error?: Shared.ProviderAuthError | Shared.UnknownError | Metadata.MessageOutputLengthError;
+  summary?: boolean;
+}
 
-    snapshot?: string;
+export namespace AssistantMessage {
+  export interface Path {
+    cwd: string;
+
+    root: string;
   }
 
-  export namespace Metadata {
-    export interface Time {
-      created: number;
+  export interface Time {
+    created: number;
 
-      completed?: number;
-    }
+    completed?: number;
+  }
 
-    export interface Tool {
-      time: Tool.Time;
+  export interface Tokens {
+    cache: Tokens.Cache;
 
-      title: string;
+    input: number;
 
-      snapshot?: string;
+    output: number;
 
-      [k: string]: unknown;
-    }
+    reasoning: number;
+  }
 
-    export namespace Tool {
-      export interface Time {
-        end: number;
+  export namespace Tokens {
+    export interface Cache {
+      read: number;
 
-        start: number;
-      }
+      write: number;
     }
+  }
 
-    export interface Assistant {
-      cost: number;
-
-      modelID: string;
-
-      path: Assistant.Path;
-
-      providerID: string;
+  export interface MessageOutputLengthError {
+    data: unknown;
 
-      system: Array<string>;
+    name: 'MessageOutputLengthError';
+  }
+}
 
-      tokens: Assistant.Tokens;
+export type AssistantMessagePart = TextPart | ToolPart | StepStartPart;
 
-      summary?: boolean;
-    }
+export interface FilePart {
+  mime: string;
 
-    export namespace Assistant {
-      export interface Path {
-        cwd: string;
+  type: 'file';
 
-        root: string;
-      }
+  url: string;
 
-      export interface Tokens {
-        cache: Tokens.Cache;
+  filename?: string;
+}
 
-        input: number;
+export type Message = Message.UserMessage | AssistantMessage;
 
-        output: number;
+export namespace Message {
+  export interface UserMessage {
+    id: string;
 
-        reasoning: number;
-      }
+    parts: Array<SessionAPI.UserMessagePart>;
 
-      export namespace Tokens {
-        export interface Cache {
-          read: number;
+    role: 'user';
 
-          write: number;
-        }
-      }
-    }
+    sessionID: string;
 
-    export interface MessageOutputLengthError {
-      data: unknown;
+    time: UserMessage.Time;
+  }
 
-      name: 'MessageOutputLengthError';
+  export namespace UserMessage {
+    export interface Time {
+      created: number;
     }
   }
 }
 
-export type MessagePart =
-  | TextPart
-  | ReasoningPart
-  | ToolInvocationPart
-  | SourceURLPart
-  | FilePart
-  | StepStartPart;
-
-export interface ReasoningPart {
-  text: string;
-
-  type: 'reasoning';
-
-  providerMetadata?: { [key: string]: unknown };
-}
-
 export interface Session {
   id: string;
 
@@ -244,18 +219,6 @@ export namespace Session {
   }
 }
 
-export interface SourceURLPart {
-  sourceId: string;
-
-  type: 'source-url';
-
-  url: string;
-
-  providerMetadata?: { [key: string]: unknown };
-
-  title?: string;
-}
-
 export interface StepStartPart {
   type: 'step-start';
 }
@@ -266,50 +229,80 @@ export interface TextPart {
   type: 'text';
 }
 
-export interface ToolCall {
-  state: 'call';
+export interface ToolPart {
+  id: string;
+
+  state: ToolStatePending | ToolStateRunning | ToolStateCompleted | ToolStateError;
+
+  tool: string;
+
+  type: 'tool';
+}
+
+export interface ToolStateCompleted {
+  metadata: { [key: string]: unknown };
+
+  output: string;
 
-  toolCallId: string;
+  status: 'completed';
 
-  toolName: string;
+  time: ToolStateCompleted.Time;
 
-  args?: unknown;
+  title: string;
 
-  step?: number;
+  input?: unknown;
 }
 
-export interface ToolInvocationPart {
-  toolInvocation: ToolCall | ToolPartialCall | ToolResult;
+export namespace ToolStateCompleted {
+  export interface Time {
+    end: number;
 
-  type: 'tool-invocation';
+    start: number;
+  }
 }
 
-export interface ToolPartialCall {
-  state: 'partial-call';
+export interface ToolStateError {
+  error: string;
 
-  toolCallId: string;
+  status: 'error';
 
-  toolName: string;
+  time: ToolStateError.Time;
 
-  args?: unknown;
+  input?: unknown;
+}
 
-  step?: number;
+export namespace ToolStateError {
+  export interface Time {
+    end: number;
+
+    start: number;
+  }
 }
 
-export interface ToolResult {
-  result: string;
+export interface ToolStatePending {
+  status: 'pending';
+}
 
-  state: 'result';
+export interface ToolStateRunning {
+  status: 'running';
 
-  toolCallId: string;
+  time: ToolStateRunning.Time;
 
-  toolName: string;
+  input?: unknown;
 
-  args?: unknown;
+  metadata?: { [key: string]: unknown };
 
-  step?: number;
+  title?: string;
 }
 
+export namespace ToolStateRunning {
+  export interface Time {
+    start: number;
+  }
+}
+
+export type UserMessagePart = TextPart | FilePart;
+
 export type SessionListResponse = Array<Session>;
 
 export type SessionDeleteResponse = boolean;
@@ -325,7 +318,7 @@ export type SessionSummarizeResponse = boolean;
 export interface SessionChatParams {
   modelID: string;
 
-  parts: Array<MessagePart>;
+  parts: Array<UserMessagePart>;
 
   providerID: string;
 }
@@ -344,18 +337,19 @@ export interface SessionSummarizeParams {
 
 export declare namespace SessionResource {
   export {
+    type AssistantMessage as AssistantMessage,
+    type AssistantMessagePart as AssistantMessagePart,
     type FilePart as FilePart,
     type Message as Message,
-    type MessagePart as MessagePart,
-    type ReasoningPart as ReasoningPart,
     type Session as Session,
-    type SourceURLPart as SourceURLPart,
     type StepStartPart as StepStartPart,
     type TextPart as TextPart,
-    type ToolCall as ToolCall,
-    type ToolInvocationPart as ToolInvocationPart,
-    type ToolPartialCall as ToolPartialCall,
-    type ToolResult as ToolResult,
+    type ToolPart as ToolPart,
+    type ToolStateCompleted as ToolStateCompleted,
+    type ToolStateError as ToolStateError,
+    type ToolStatePending as ToolStatePending,
+    type ToolStateRunning as ToolStateRunning,
+    type UserMessagePart as UserMessagePart,
     type SessionListResponse as SessionListResponse,
     type SessionDeleteResponse as SessionDeleteResponse,
     type SessionAbortResponse as SessionAbortResponse,

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = '0.1.0-alpha.14'; // x-release-please-version
+export const VERSION = '0.1.0-alpha.15'; // x-release-please-version