@opencode-ai/sdk 0.1.0-alpha.1 → 0.1.0-alpha.11

package/src/client.ts

@@ -16,42 +16,43 @@ import * as Errors from './core/error';
 import * as Uploads from './core/uploads';
 import * as API from './resources/index';
 import { APIPromise } from './core/api-promise';
-import { AppInfo, AppInfoCreateResponse } from './resources/app-info';
-import { AppInitialize, AppInitializeInitializeResponse } from './resources/app-initialize';
-import { ConfigGet, ConfigGetRetrieveResponse } from './resources/config-get';
+import { App, AppInitResponse, AppResource } from './resources/app';
+import {
+  Config,
+  ConfigProvidersResponse,
+  ConfigResource,
+  Keybinds,
+  McpLocal,
+  McpRemote,
+  Model,
+  Provider,
+} from './resources/config';
 import { Event, EventListResponse } from './resources/event';
-import { FileSearch, FileSearchSearchParams, FileSearchSearchResponse } from './resources/file-search';
-import { InstallationInfo, InstallationInfoCreateResponse } from './resources/installation-info';
-import { PathGet, PathGetCreateResponse } from './resources/path-get';
-import { ProviderList, ProviderListCreateResponse } from './resources/provider-list';
-import { SessionAbort, SessionAbortAbortParams, SessionAbortAbortResponse } from './resources/session-abort';
+import { File, FileSearchParams, FileSearchResponse } from './resources/file';
 import {
-  MessageInfo,
+  FilePart,
+  Message,
   MessagePart,
-  ProviderAuthError,
-  SessionChat,
-  SessionChatCreateParams,
-  UnknownError,
-} from './resources/session-chat';
-import { SessionCreate, SessionInfo } from './resources/session-create';
-import {
-  SessionInitialize,
-  SessionInitializeCreateParams,
-  SessionInitializeCreateResponse,
-} from './resources/session-initialize';
-import { SessionList, SessionListCreateResponse } from './resources/session-list';
-import {
-  SessionMessageCreateParams,
-  SessionMessageCreateResponse,
-  SessionMessages,
-} from './resources/session-messages';
-import { SessionShare, SessionShareCreateParams } from './resources/session-share';
-import {
-  SessionSummarize,
-  SessionSummarizeSummarizeParams,
-  SessionSummarizeSummarizeResponse,
-} from './resources/session-summarize';
-import { SessionUnshare, SessionUnshareUnshareParams } from './resources/session-unshare';
+  ReasoningPart,
+  Session,
+  SessionAbortResponse,
+  SessionChatParams,
+  SessionDeleteResponse,
+  SessionInitParams,
+  SessionInitResponse,
+  SessionListResponse,
+  SessionMessagesResponse,
+  SessionResource,
+  SessionSummarizeParams,
+  SessionSummarizeResponse,
+  SourceURLPart,
+  StepStartPart,
+  TextPart,
+  ToolCall,
+  ToolInvocationPart,
+  ToolPartialCall,
+  ToolResult,
+} from './resources/session';
 import { type Fetch } from './internal/builtin-types';
 import { HeadersLike, NullableHeaders, buildHeaders } from './internal/headers';
 import { FinalRequestOptions, RequestOptions } from './internal/request-options';
@@ -66,11 +67,6 @@ import {
 import { isEmptyObj } from './internal/utils/values';
 
 export interface ClientOptions {
-  /**
-   * Defaults to process.env['OPENCODE_API_KEY'].
-   */
-  apiKey?: string | null | undefined;
-
   /**
    * Override the default base URL for the API, e.g., "https://api.example.com/v2/"
    *
@@ -142,8 +138,6 @@ export interface ClientOptions {
  * API Client for interfacing with the Opencode API.
  */
 export class Opencode {
-  apiKey: string | null;
-
   baseURL: string;
   maxRetries: number;
   timeout: number;
@@ -159,7 +153,6 @@ export class Opencode {
   /**
    * API Client for interfacing with the Opencode API.
    *
-   * @param {string | null | undefined} [opts.apiKey=process.env['OPENCODE_API_KEY'] ?? null]
    * @param {string} [opts.baseURL=process.env['OPENCODE_BASE_URL'] ?? http://localhost:54321] - Override the default base URL for the API.
    * @param {number} [opts.timeout=1 minute] - The maximum amount of time (in milliseconds) the client will wait for a response before timing out.
    * @param {MergedRequestInit} [opts.fetchOptions] - Additional `RequestInit` options to be passed to `fetch` calls.
@@ -168,13 +161,8 @@ export class Opencode {
    * @param {HeadersLike} opts.defaultHeaders - Default headers to include with every request to the API.
    * @param {Record<string, string | undefined>} opts.defaultQuery - Default query parameters to include with every request to the API.
    */
-  constructor({
-    baseURL = readEnv('OPENCODE_BASE_URL'),
-    apiKey = readEnv('OPENCODE_API_KEY') ?? null,
-    ...opts
-  }: ClientOptions = {}) {
+  constructor({ baseURL = readEnv('OPENCODE_BASE_URL'), ...opts }: ClientOptions = {}) {
     const options: ClientOptions = {
-      apiKey,
       ...opts,
       baseURL: baseURL || `http://localhost:54321`,
     };
@@ -195,8 +183,6 @@ export class Opencode {
     this.#encoder = Opts.FallbackEncoder;
 
     this._options = options;
-
-    this.apiKey = apiKey;
   }
 
   /**
@@ -212,7 +198,6 @@ export class Opencode {
       logLevel: this.logLevel,
       fetch: this.fetch,
       fetchOptions: this.fetchOptions,
-      apiKey: this.apiKey,
       ...options,
     });
   }
@@ -229,23 +214,7 @@ export class Opencode {
   }
 
   protected validateHeaders({ values, nulls }: NullableHeaders) {
-    if (this.apiKey && values.get('authorization')) {
-      return;
-    }
-    if (nulls.has('authorization')) {
-      return;
-    }
-
-    throw new Error(
-      'Could not resolve authentication method. Expected the apiKey to be set. Or for the "Authorization" headers to be explicitly omitted',
-    );
-  }
-
-  protected authHeaders(opts: FinalRequestOptions): NullableHeaders | undefined {
-    if (this.apiKey == null) {
-      return undefined;
-    }
-    return buildHeaders([{ Authorization: `Bearer ${this.apiKey}` }]);
+    return;
   }
 
   /**
@@ -683,7 +652,6 @@ export class Opencode {
         ...(options.timeout ? { 'X-Stainless-Timeout': String(Math.trunc(options.timeout / 1000)) } : {}),
         ...getPlatformHeaders(),
       },
-      this.authHeaders(options),
       this._options.defaultHeaders,
       bodyHeaders,
       options.headers,
@@ -751,110 +719,65 @@ export class Opencode {
   static toFile = Uploads.toFile;
 
   event: API.Event = new API.Event(this);
-  appInfo: API.AppInfo = new API.AppInfo(this);
-  configGet: API.ConfigGet = new API.ConfigGet(this);
-  appInitialize: API.AppInitialize = new API.AppInitialize(this);
-  sessionInitialize: API.SessionInitialize = new API.SessionInitialize(this);
-  pathGet: API.PathGet = new API.PathGet(this);
-  sessionCreate: API.SessionCreate = new API.SessionCreate(this);
-  sessionShare: API.SessionShare = new API.SessionShare(this);
-  sessionUnshare: API.SessionUnshare = new API.SessionUnshare(this);
-  sessionMessages: API.SessionMessages = new API.SessionMessages(this);
-  sessionList: API.SessionList = new API.SessionList(this);
-  sessionAbort: API.SessionAbort = new API.SessionAbort(this);
-  sessionSummarize: API.SessionSummarize = new API.SessionSummarize(this);
-  sessionChat: API.SessionChat = new API.SessionChat(this);
-  providerList: API.ProviderList = new API.ProviderList(this);
-  fileSearch: API.FileSearch = new API.FileSearch(this);
-  installationInfo: API.InstallationInfo = new API.InstallationInfo(this);
+  app: API.AppResource = new API.AppResource(this);
+  file: API.File = new API.File(this);
+  config: API.ConfigResource = new API.ConfigResource(this);
+  session: API.SessionResource = new API.SessionResource(this);
 }
 Opencode.Event = Event;
-Opencode.AppInfo = AppInfo;
-Opencode.ConfigGet = ConfigGet;
-Opencode.AppInitialize = AppInitialize;
-Opencode.SessionInitialize = SessionInitialize;
-Opencode.PathGet = PathGet;
-Opencode.SessionCreate = SessionCreate;
-Opencode.SessionShare = SessionShare;
-Opencode.SessionUnshare = SessionUnshare;
-Opencode.SessionMessages = SessionMessages;
-Opencode.SessionList = SessionList;
-Opencode.SessionAbort = SessionAbort;
-Opencode.SessionSummarize = SessionSummarize;
-Opencode.SessionChat = SessionChat;
-Opencode.ProviderList = ProviderList;
-Opencode.FileSearch = FileSearch;
-Opencode.InstallationInfo = InstallationInfo;
+Opencode.AppResource = AppResource;
+Opencode.File = File;
+Opencode.ConfigResource = ConfigResource;
+Opencode.SessionResource = SessionResource;
 export declare namespace Opencode {
   export type RequestOptions = Opts.RequestOptions;
 
   export { Event as Event, type EventListResponse as EventListResponse };
 
-  export { AppInfo as AppInfo, type AppInfoCreateResponse as AppInfoCreateResponse };
-
-  export { ConfigGet as ConfigGet, type ConfigGetRetrieveResponse as ConfigGetRetrieveResponse };
+  export { AppResource as AppResource, type App as App, type AppInitResponse as AppInitResponse };
 
   export {
-    AppInitialize as AppInitialize,
-    type AppInitializeInitializeResponse as AppInitializeInitializeResponse,
+    File as File,
+    type FileSearchResponse as FileSearchResponse,
+    type FileSearchParams as FileSearchParams,
   };
 
   export {
-    SessionInitialize as SessionInitialize,
-    type SessionInitializeCreateResponse as SessionInitializeCreateResponse,
-    type SessionInitializeCreateParams as SessionInitializeCreateParams,
+    ConfigResource as ConfigResource,
+    type Config as Config,
+    type Keybinds as Keybinds,
+    type McpLocal as McpLocal,
+    type McpRemote as McpRemote,
+    type Model as Model,
+    type Provider as Provider,
+    type ConfigProvidersResponse as ConfigProvidersResponse,
   };
 
-  export { PathGet as PathGet, type PathGetCreateResponse as PathGetCreateResponse };
-
-  export { SessionCreate as SessionCreate, type SessionInfo as SessionInfo };
-
-  export { SessionShare as SessionShare, type SessionShareCreateParams as SessionShareCreateParams };
-
   export {
-    SessionUnshare as SessionUnshare,
-    type SessionUnshareUnshareParams as SessionUnshareUnshareParams,
-  };
-
-  export {
-    SessionMessages as SessionMessages,
-    type SessionMessageCreateResponse as SessionMessageCreateResponse,
-    type SessionMessageCreateParams as SessionMessageCreateParams,
-  };
-
-  export { SessionList as SessionList, type SessionListCreateResponse as SessionListCreateResponse };
-
-  export {
-    SessionAbort as SessionAbort,
-    type SessionAbortAbortResponse as SessionAbortAbortResponse,
-    type SessionAbortAbortParams as SessionAbortAbortParams,
-  };
-
-  export {
-    SessionSummarize as SessionSummarize,
-    type SessionSummarizeSummarizeResponse as SessionSummarizeSummarizeResponse,
-    type SessionSummarizeSummarizeParams as SessionSummarizeSummarizeParams,
-  };
-
-  export {
-    SessionChat as SessionChat,
-    type MessageInfo as MessageInfo,
+    SessionResource as SessionResource,
+    type FilePart as FilePart,
+    type Message as Message,
     type MessagePart as MessagePart,
-    type ProviderAuthError as ProviderAuthError,
-    type UnknownError as UnknownError,
-    type SessionChatCreateParams as SessionChatCreateParams,
+    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 SessionListResponse as SessionListResponse,
+    type SessionDeleteResponse as SessionDeleteResponse,
+    type SessionAbortResponse as SessionAbortResponse,
+    type SessionInitResponse as SessionInitResponse,
+    type SessionMessagesResponse as SessionMessagesResponse,
+    type SessionSummarizeResponse as SessionSummarizeResponse,
+    type SessionChatParams as SessionChatParams,
+    type SessionInitParams as SessionInitParams,
+    type SessionSummarizeParams as SessionSummarizeParams,
   };
 
-  export { ProviderList as ProviderList, type ProviderListCreateResponse as ProviderListCreateResponse };
-
-  export {
-    FileSearch as FileSearch,
-    type FileSearchSearchResponse as FileSearchSearchResponse,
-    type FileSearchSearchParams as FileSearchSearchParams,
-  };
-
-  export {
-    InstallationInfo as InstallationInfo,
-    type InstallationInfoCreateResponse as InstallationInfoCreateResponse,
-  };
+  export type ProviderAuthError = API.ProviderAuthError;
+  export type UnknownError = API.UnknownError;
 }

package/src/core/streaming.ts

@@ -0,0 +1,301 @@
+import { OpencodeError } from './error';
+import { type ReadableStream } from '../internal/shim-types';
+import { makeReadableStream } from '../internal/shims';
+import { findDoubleNewlineIndex, LineDecoder } from '../internal/decoders/line';
+import { ReadableStreamToAsyncIterable } from '../internal/shims';
+import { isAbortError } from '../internal/errors';
+import { encodeUTF8 } from '../internal/utils/bytes';
+
+type Bytes = string | ArrayBuffer | Uint8Array | null | undefined;
+
+export type ServerSentEvent = {
+  event: string | null;
+  data: string;
+  raw: string[];
+};
+
+export class Stream<Item> implements AsyncIterable<Item> {
+  controller: AbortController;
+
+  constructor(
+    private iterator: () => AsyncIterator<Item>,
+    controller: AbortController,
+  ) {
+    this.controller = controller;
+  }
+
+  static fromSSEResponse<Item>(response: Response, controller: AbortController): Stream<Item> {
+    let consumed = false;
+
+    async function* iterator(): AsyncIterator<Item, any, undefined> {
+      if (consumed) {
+        throw new OpencodeError('Cannot iterate over a consumed stream, use `.tee()` to split the stream.');
+      }
+      consumed = true;
+      let done = false;
+      try {
+        for await (const sse of _iterSSEMessages(response, controller)) {
+          try {
+            yield JSON.parse(sse.data);
+          } catch (e) {
+            console.error(`Could not parse message into JSON:`, sse.data);
+            console.error(`From chunk:`, sse.raw);
+            throw e;
+          }
+        }
+        done = true;
+      } catch (e) {
+        // If the user calls `stream.controller.abort()`, we should exit without throwing.
+        if (isAbortError(e)) return;
+        throw e;
+      } finally {
+        // If the user `break`s, abort the ongoing request.
+        if (!done) controller.abort();
+      }
+    }
+
+    return new Stream(iterator, controller);
+  }
+
+  /**
+   * Generates a Stream from a newline-separated ReadableStream
+   * where each item is a JSON value.
+   */
+  static fromReadableStream<Item>(readableStream: ReadableStream, controller: AbortController): Stream<Item> {
+    let consumed = false;
+
+    async function* iterLines(): AsyncGenerator<string, void, unknown> {
+      const lineDecoder = new LineDecoder();
+
+      const iter = ReadableStreamToAsyncIterable<Bytes>(readableStream);
+      for await (const chunk of iter) {
+        for (const line of lineDecoder.decode(chunk)) {
+          yield line;
+        }
+      }
+
+      for (const line of lineDecoder.flush()) {
+        yield line;
+      }
+    }
+
+    async function* iterator(): AsyncIterator<Item, any, undefined> {
+      if (consumed) {
+        throw new OpencodeError('Cannot iterate over a consumed stream, use `.tee()` to split the stream.');
+      }
+      consumed = true;
+      let done = false;
+      try {
+        for await (const line of iterLines()) {
+          if (done) continue;
+          if (line) yield JSON.parse(line);
+        }
+        done = true;
+      } catch (e) {
+        // If the user calls `stream.controller.abort()`, we should exit without throwing.
+        if (isAbortError(e)) return;
+        throw e;
+      } finally {
+        // If the user `break`s, abort the ongoing request.
+        if (!done) controller.abort();
+      }
+    }
+
+    return new Stream(iterator, controller);
+  }
+
+  [Symbol.asyncIterator](): AsyncIterator<Item> {
+    return this.iterator();
+  }
+
+  /**
+   * Splits the stream into two streams which can be
+   * independently read from at different speeds.
+   */
+  tee(): [Stream<Item>, Stream<Item>] {
+    const left: Array<Promise<IteratorResult<Item>>> = [];
+    const right: Array<Promise<IteratorResult<Item>>> = [];
+    const iterator = this.iterator();
+
+    const teeIterator = (queue: Array<Promise<IteratorResult<Item>>>): AsyncIterator<Item> => {
+      return {
+        next: () => {
+          if (queue.length === 0) {
+            const result = iterator.next();
+            left.push(result);
+            right.push(result);
+          }
+          return queue.shift()!;
+        },
+      };
+    };
+
+    return [
+      new Stream(() => teeIterator(left), this.controller),
+      new Stream(() => teeIterator(right), this.controller),
+    ];
+  }
+
+  /**
+   * Converts this stream to a newline-separated ReadableStream of
+   * JSON stringified values in the stream
+   * which can be turned back into a Stream with `Stream.fromReadableStream()`.
+   */
+  toReadableStream(): ReadableStream {
+    const self = this;
+    let iter: AsyncIterator<Item>;
+
+    return makeReadableStream({
+      async start() {
+        iter = self[Symbol.asyncIterator]();
+      },
+      async pull(ctrl: any) {
+        try {
+          const { value, done } = await iter.next();
+          if (done) return ctrl.close();
+
+          const bytes = encodeUTF8(JSON.stringify(value) + '\n');
+
+          ctrl.enqueue(bytes);
+        } catch (err) {
+          ctrl.error(err);
+        }
+      },
+      async cancel() {
+        await iter.return?.();
+      },
+    });
+  }
+}
+
+export async function* _iterSSEMessages(
+  response: Response,
+  controller: AbortController,
+): AsyncGenerator<ServerSentEvent, void, unknown> {
+  if (!response.body) {
+    controller.abort();
+    if (
+      typeof (globalThis as any).navigator !== 'undefined' &&
+      (globalThis as any).navigator.product === 'ReactNative'
+    ) {
+      throw new OpencodeError(
+        `The default react-native fetch implementation does not support streaming. Please use expo/fetch: https://docs.expo.dev/versions/latest/sdk/expo/#expofetch-api`,
+      );
+    }
+    throw new OpencodeError(`Attempted to iterate over a response with no body`);
+  }
+
+  const sseDecoder = new SSEDecoder();
+  const lineDecoder = new LineDecoder();
+
+  const iter = ReadableStreamToAsyncIterable<Bytes>(response.body);
+  for await (const sseChunk of iterSSEChunks(iter)) {
+    for (const line of lineDecoder.decode(sseChunk)) {
+      const sse = sseDecoder.decode(line);
+      if (sse) yield sse;
+    }
+  }
+
+  for (const line of lineDecoder.flush()) {
+    const sse = sseDecoder.decode(line);
+    if (sse) yield sse;
+  }
+}
+
+/**
+ * Given an async iterable iterator, iterates over it and yields full
+ * SSE chunks, i.e. yields when a double new-line is encountered.
+ */
+async function* iterSSEChunks(iterator: AsyncIterableIterator<Bytes>): AsyncGenerator<Uint8Array> {
+  let data = new Uint8Array();
+
+  for await (const chunk of iterator) {
+    if (chunk == null) {
+      continue;
+    }
+
+    const binaryChunk =
+      chunk instanceof ArrayBuffer ? new Uint8Array(chunk)
+      : typeof chunk === 'string' ? encodeUTF8(chunk)
+      : chunk;
+
+    let newData = new Uint8Array(data.length + binaryChunk.length);
+    newData.set(data);
+    newData.set(binaryChunk, data.length);
+    data = newData;
+
+    let patternIndex;
+    while ((patternIndex = findDoubleNewlineIndex(data)) !== -1) {
+      yield data.slice(0, patternIndex);
+      data = data.slice(patternIndex);
+    }
+  }
+
+  if (data.length > 0) {
+    yield data;
+  }
+}
+
+class SSEDecoder {
+  private data: string[];
+  private event: string | null;
+  private chunks: string[];
+
+  constructor() {
+    this.event = null;
+    this.data = [];
+    this.chunks = [];
+  }
+
+  decode(line: string) {
+    if (line.endsWith('\r')) {
+      line = line.substring(0, line.length - 1);
+    }
+
+    if (!line) {
+      // empty line and we didn't previously encounter any messages
+      if (!this.event && !this.data.length) return null;
+
+      const sse: ServerSentEvent = {
+        event: this.event,
+        data: this.data.join('\n'),
+        raw: this.chunks,
+      };
+
+      this.event = null;
+      this.data = [];
+      this.chunks = [];
+
+      return sse;
+    }
+
+    this.chunks.push(line);
+
+    if (line.startsWith(':')) {
+      return null;
+    }
+
+    let [fieldname, _, value] = partition(line, ':');
+
+    if (value.startsWith(' ')) {
+      value = value.substring(1);
+    }
+
+    if (fieldname === 'event') {
+      this.event = value;
+    } else if (fieldname === 'data') {
+      this.data.push(value);
+    }
+
+    return null;
+  }
+}
+
+function partition(str: string, delimiter: string): [string, string, string] {
+  const index = str.indexOf(delimiter);
+  if (index !== -1) {
+    return [str.substring(0, index), delimiter, str.substring(index + delimiter.length)];
+  }
+
+  return [str, '', ''];
+}