casedev 0.31.4 → 0.33.0

package/src/internal/qs/utils.ts

@@ -0,0 +1,265 @@
+import { RFC1738 } from './formats';
+import type { DefaultEncoder, Format } from './types';
+import { isArray } from '../utils/values';
+
+export let has = (obj: object, key: PropertyKey): boolean => (
+  (has = (Object as any).hasOwn ?? Function.prototype.call.bind(Object.prototype.hasOwnProperty)),
+  has(obj, key)
+);
+
+const hex_table = /* @__PURE__ */ (() => {
+  const array = [];
+  for (let i = 0; i < 256; ++i) {
+    array.push('%' + ((i < 16 ? '0' : '') + i.toString(16)).toUpperCase());
+  }
+
+  return array;
+})();
+
+function compact_queue<T extends Record<string, any>>(queue: Array<{ obj: T; prop: string }>) {
+  while (queue.length > 1) {
+    const item = queue.pop();
+    if (!item) continue;
+
+    const obj = item.obj[item.prop];
+
+    if (isArray(obj)) {
+      const compacted: unknown[] = [];
+
+      for (let j = 0; j < obj.length; ++j) {
+        if (typeof obj[j] !== 'undefined') {
+          compacted.push(obj[j]);
+        }
+      }
+
+      // @ts-ignore
+      item.obj[item.prop] = compacted;
+    }
+  }
+}
+
+function array_to_object(source: any[], options: { plainObjects: boolean }) {
+  const obj = options && options.plainObjects ? Object.create(null) : {};
+  for (let i = 0; i < source.length; ++i) {
+    if (typeof source[i] !== 'undefined') {
+      obj[i] = source[i];
+    }
+  }
+
+  return obj;
+}
+
+export function merge(
+  target: any,
+  source: any,
+  options: { plainObjects?: boolean; allowPrototypes?: boolean } = {},
+) {
+  if (!source) {
+    return target;
+  }
+
+  if (typeof source !== 'object') {
+    if (isArray(target)) {
+      target.push(source);
+    } else if (target && typeof target === 'object') {
+      if ((options && (options.plainObjects || options.allowPrototypes)) || !has(Object.prototype, source)) {
+        target[source] = true;
+      }
+    } else {
+      return [target, source];
+    }
+
+    return target;
+  }
+
+  if (!target || typeof target !== 'object') {
+    return [target].concat(source);
+  }
+
+  let mergeTarget = target;
+  if (isArray(target) && !isArray(source)) {
+    // @ts-ignore
+    mergeTarget = array_to_object(target, options);
+  }
+
+  if (isArray(target) && isArray(source)) {
+    source.forEach(function (item, i) {
+      if (has(target, i)) {
+        const targetItem = target[i];
+        if (targetItem && typeof targetItem === 'object' && item && typeof item === 'object') {
+          target[i] = merge(targetItem, item, options);
+        } else {
+          target.push(item);
+        }
+      } else {
+        target[i] = item;
+      }
+    });
+    return target;
+  }
+
+  return Object.keys(source).reduce(function (acc, key) {
+    const value = source[key];
+
+    if (has(acc, key)) {
+      acc[key] = merge(acc[key], value, options);
+    } else {
+      acc[key] = value;
+    }
+    return acc;
+  }, mergeTarget);
+}
+
+export function assign_single_source(target: any, source: any) {
+  return Object.keys(source).reduce(function (acc, key) {
+    acc[key] = source[key];
+    return acc;
+  }, target);
+}
+
+export function decode(str: string, _: any, charset: string) {
+  const strWithoutPlus = str.replace(/\+/g, ' ');
+  if (charset === 'iso-8859-1') {
+    // unescape never throws, no try...catch needed:
+    return strWithoutPlus.replace(/%[0-9a-f]{2}/gi, unescape);
+  }
+  // utf-8
+  try {
+    return decodeURIComponent(strWithoutPlus);
+  } catch (e) {
+    return strWithoutPlus;
+  }
+}
+
+const limit = 1024;
+
+export const encode: (
+  str: any,
+  defaultEncoder: DefaultEncoder,
+  charset: string,
+  type: 'key' | 'value',
+  format: Format,
+) => string = (str, _defaultEncoder, charset, _kind, format: Format) => {
+  // This code was originally written by Brian White for the io.js core querystring library.
+  // It has been adapted here for stricter adherence to RFC 3986
+  if (str.length === 0) {
+    return str;
+  }
+
+  let string = str;
+  if (typeof str === 'symbol') {
+    string = Symbol.prototype.toString.call(str);
+  } else if (typeof str !== 'string') {
+    string = String(str);
+  }
+
+  if (charset === 'iso-8859-1') {
+    return escape(string).replace(/%u[0-9a-f]{4}/gi, function ($0) {
+      return '%26%23' + parseInt($0.slice(2), 16) + '%3B';
+    });
+  }
+
+  let out = '';
+  for (let j = 0; j < string.length; j += limit) {
+    const segment = string.length >= limit ? string.slice(j, j + limit) : string;
+    const arr = [];
+
+    for (let i = 0; i < segment.length; ++i) {
+      let c = segment.charCodeAt(i);
+      if (
+        c === 0x2d || // -
+        c === 0x2e || // .
+        c === 0x5f || // _
+        c === 0x7e || // ~
+        (c >= 0x30 && c <= 0x39) || // 0-9
+        (c >= 0x41 && c <= 0x5a) || // a-z
+        (c >= 0x61 && c <= 0x7a) || // A-Z
+        (format === RFC1738 && (c === 0x28 || c === 0x29)) // ( )
+      ) {
+        arr[arr.length] = segment.charAt(i);
+        continue;
+      }
+
+      if (c < 0x80) {
+        arr[arr.length] = hex_table[c];
+        continue;
+      }
+
+      if (c < 0x800) {
+        arr[arr.length] = hex_table[0xc0 | (c >> 6)]! + hex_table[0x80 | (c & 0x3f)];
+        continue;
+      }
+
+      if (c < 0xd800 || c >= 0xe000) {
+        arr[arr.length] =
+          hex_table[0xe0 | (c >> 12)]! + hex_table[0x80 | ((c >> 6) & 0x3f)] + hex_table[0x80 | (c & 0x3f)];
+        continue;
+      }
+
+      i += 1;
+      c = 0x10000 + (((c & 0x3ff) << 10) | (segment.charCodeAt(i) & 0x3ff));
+
+      arr[arr.length] =
+        hex_table[0xf0 | (c >> 18)]! +
+        hex_table[0x80 | ((c >> 12) & 0x3f)] +
+        hex_table[0x80 | ((c >> 6) & 0x3f)] +
+        hex_table[0x80 | (c & 0x3f)];
+    }
+
+    out += arr.join('');
+  }
+
+  return out;
+};
+
+export function compact(value: any) {
+  const queue = [{ obj: { o: value }, prop: 'o' }];
+  const refs = [];
+
+  for (let i = 0; i < queue.length; ++i) {
+    const item = queue[i];
+    // @ts-ignore
+    const obj = item.obj[item.prop];
+
+    const keys = Object.keys(obj);
+    for (let j = 0; j < keys.length; ++j) {
+      const key = keys[j]!;
+      const val = obj[key];
+      if (typeof val === 'object' && val !== null && refs.indexOf(val) === -1) {
+        queue.push({ obj: obj, prop: key });
+        refs.push(val);
+      }
+    }
+  }
+
+  compact_queue(queue);
+
+  return value;
+}
+
+export function is_regexp(obj: any) {
+  return Object.prototype.toString.call(obj) === '[object RegExp]';
+}
+
+export function is_buffer(obj: any) {
+  if (!obj || typeof obj !== 'object') {
+    return false;
+  }
+
+  return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj));
+}
+
+export function combine(a: any, b: any) {
+  return [].concat(a, b);
+}
+
+export function maybe_map<T>(val: T[], fn: (v: T) => T) {
+  if (isArray(val)) {
+    const mapped = [];
+    for (let i = 0; i < val.length; i += 1) {
+      mapped.push(fn(val[i]!));
+    }
+    return mapped;
+  }
+  return fn(val);
+}

package/src/internal/utils/query.ts

@@ -1,23 +1,7 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-import { CasedevError } from '../../core/error';
+import * as qs from '../qs/stringify';
 
-/**
- * Basic re-implementation of `qs.stringify` for primitive types.
- */
 export function stringifyQuery(query: object | Record<string, unknown>) {
-  return Object.entries(query)
-    .filter(([_, value]) => typeof value !== 'undefined')
-    .map(([key, value]) => {
-      if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
-        return `${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
-      }
-      if (value === null) {
-        return `${encodeURIComponent(key)}=`;
-      }
-      throw new CasedevError(
-        `Cannot stringify type ${typeof value}; Expected string, number, boolean, or null. If you need to pass nested query parameters, you can manually encode them, e.g. { query: { 'foo[key1]': value1, 'foo[key2]': value2 } }, and please open a GitHub issue requesting better support for your use case.`,
-      );
-    })
-    .join('&');
+  return qs.stringify(query, { arrayFormat: 'comma' });
 }

package/src/resources/agent/agent.ts

@@ -3,13 +3,19 @@
 import { APIResource } from '../../core/resource';
 import * as V1API from './v1/v1';
 import { V1 } from './v1/v1';
+import * as V2API from './v2/v2';
+import { V2 } from './v2/v2';
 
 export class Agent extends APIResource {
   v1: V1API.V1 = new V1API.V1(this._client);
+  v2: V2API.V2 = new V2API.V2(this._client);
 }
 
 Agent.V1 = V1;
+Agent.V2 = V2;
 
 export declare namespace Agent {
   export { V1 as V1 };
+
+  export { V2 as V2 };
 }

package/src/resources/agent/index.ts

@@ -2,3 +2,4 @@
 
 export { Agent } from './agent';
 export { V1 } from './v1/index';
+export { V2 } from './v2/index';

package/src/resources/agent/v2/chat/chat.ts

@@ -0,0 +1,272 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../../../core/resource';
+import * as FilesAPI from './files';
+import { FileDownloadParams, FileListResponse, Files } from './files';
+import { APIPromise } from '../../../../core/api-promise';
+import { Stream } from '../../../../core/streaming';
+import { buildHeaders } from '../../../../internal/headers';
+import { RequestOptions } from '../../../../internal/request-options';
+import { path } from '../../../../internal/utils/path';
+
+/**
+ * Create, manage, and execute AI agents with tool access, sandbox environments, and async run workflows
+ */
+export class Chat extends APIResource {
+  files: FilesAPI.Files = new FilesAPI.Files(this._client);
+
+  /**
+   * Creates a persistent OpenCode chat session backed by a Daytona runtime. Session
+   * state is retained and can be resumed or recovered across requests.
+   */
+  create(
+    body: ChatCreateParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<ChatCreateResponse> {
+    return this._client.post('/agent/v2/chat', { body, ...options });
+  }
+
+  /**
+   * Terminates the active Daytona runtime (if any), then marks the chat as ended.
+   */
+  delete(id: string, options?: RequestOptions): APIPromise<ChatDeleteResponse> {
+    return this._client.delete(path`/agent/v2/chat/${id}`, options);
+  }
+
+  /**
+   * Aborts the active OpenCode generation for this Daytona-backed chat session.
+   */
+  cancel(id: string, options?: RequestOptions): APIPromise<ChatCancelResponse> {
+    return this._client.post(path`/agent/v2/chat/${id}/cancel`, options);
+  }
+
+  /**
+   * Answers a pending OpenCode question for the Daytona-backed chat session and
+   * resumes or recovers the runtime if needed.
+   */
+  replyToQuestion(
+    requestID: string,
+    params: ChatReplyToQuestionParams,
+    options?: RequestOptions,
+  ): APIPromise<void> {
+    const { id, ...body } = params;
+    return this._client.post(path`/agent/v2/chat/${id}/question/${requestID}/reply`, {
+      body,
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+
+  /**
+   * Streams a single assistant turn from a Daytona-backed chat runtime as normalized
+   * SSE events with stable turn, message, and part IDs. Emits events:
+   * `turn.started`, `turn.status`, `message.created`, `message.part.updated`,
+   * `message.completed`, `session.usage`, `turn.completed`.
+   *
+   * **When to use this endpoint:** Recommended for building custom chat UIs that
+   * need real-time streaming progress. This is the primary streaming endpoint for
+   * new integrations.
+   *
+   * **Alternatives:**
+   *
+   * - `POST /chat/:id/message` — synchronous, returns complete response as JSON
+   *   (best for server-to-server)
+   */
+  respond(
+    id: string,
+    body: ChatRespondParams,
+    options?: RequestOptions,
+  ): APIPromise<Stream<ChatRespondResponse>> {
+    return this._client.post(path`/agent/v2/chat/${id}/respond`, {
+      body,
+      ...options,
+      headers: buildHeaders([{ Accept: 'text/event-stream' }, options?.headers]),
+      stream: true,
+    }) as APIPromise<Stream<ChatRespondResponse>>;
+  }
+
+  /**
+   * Sends a message to a Daytona-backed chat runtime and returns the complete
+   * response as a single JSON body. Blocks until the assistant turn completes.
+   *
+   * **When to use this endpoint:** Best for server-to-server integrations,
+   * background processing, or any context where you want the full response in one
+   * call without managing an SSE stream.
+   *
+   * **Alternatives:**
+   *
+   * - `POST /chat/:id/respond` — streaming SSE with normalized events (recommended
+   *   for custom chat UIs)
+   */
+  sendMessage(id: string, body: ChatSendMessageParams, options?: RequestOptions): APIPromise<void> {
+    return this._client.post(path`/agent/v2/chat/${id}/message`, {
+      body,
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+
+  /**
+   * Relays OpenCode SSE events for this Daytona-backed chat runtime. Supports replay
+   * from buffered events using Last-Event-ID and transparently reconnects stopped or
+   * archived runtimes.
+   */
+  stream(
+    id: string,
+    query: ChatStreamParams | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<Stream<ChatStreamResponse>> {
+    return this._client.get(path`/agent/v2/chat/${id}/stream`, {
+      query,
+      ...options,
+      headers: buildHeaders([{ Accept: 'text/event-stream' }, options?.headers]),
+      stream: true,
+    }) as APIPromise<Stream<ChatStreamResponse>>;
+  }
+}
+
+export interface ChatCreateResponse {
+  id?: string;
+
+  createdAt?: string;
+
+  idleTimeoutMs?: number;
+
+  provider?: 'daytona';
+
+  runtimeState?: string;
+
+  status?: string;
+}
+
+export interface ChatDeleteResponse {
+  id?: string;
+
+  cost?: number;
+
+  provider?: string | null;
+
+  runtimeId?: string | null;
+
+  runtimeMs?: number;
+
+  status?: string;
+}
+
+export interface ChatCancelResponse {
+  id?: string;
+
+  ok?: boolean;
+}
+
+export type ChatRespondResponse = string;
+
+export type ChatStreamResponse = string;
+
+export interface ChatCreateParams {
+  /**
+   * Idle timeout before the runtime is eligible to stop. Defaults to 15 minutes.
+   */
+  idleTimeoutMs?: number | null;
+
+  /**
+   * Optional model override for the OpenCode session
+   */
+  model?: string | null;
+
+  /**
+   * Optional human-readable session title
+   */
+  title?: string;
+
+  /**
+   * Restrict the chat session to specific vault IDs
+   */
+  vaultIds?: Array<string> | null;
+}
+
+export interface ChatReplyToQuestionParams {
+  /**
+   * Path param: Chat session ID
+   */
+  id: string;
+
+  /**
+   * Body param: Answer selections for each prompt element in the pending question
+   */
+  answers: Array<Array<string>>;
+}
+
+export interface ChatRespondParams {
+  /**
+   * Message content parts. Currently only "text" type is supported. Additional types
+   * (e.g. file, image) may be added in future versions.
+   */
+  parts?: Array<ChatRespondParams.Part>;
+}
+
+export namespace ChatRespondParams {
+  export interface Part {
+    /**
+     * The message text content
+     */
+    text: string;
+
+    /**
+     * Part type. Currently only "text" is supported.
+     */
+    type: 'text';
+  }
+}
+
+export interface ChatSendMessageParams {
+  /**
+   * Message content parts. Currently only "text" type is supported. Additional types
+   * (e.g. file, image) may be added in future versions.
+   */
+  parts?: Array<ChatSendMessageParams.Part>;
+}
+
+export namespace ChatSendMessageParams {
+  export interface Part {
+    /**
+     * The message text content
+     */
+    text: string;
+
+    /**
+     * Part type. Currently only "text" is supported.
+     */
+    type: 'text';
+  }
+}
+
+export interface ChatStreamParams {
+  /**
+   * Replay events after this sequence number
+   */
+  lastEventId?: number;
+}
+
+Chat.Files = Files;
+
+export declare namespace Chat {
+  export {
+    type ChatCreateResponse as ChatCreateResponse,
+    type ChatDeleteResponse as ChatDeleteResponse,
+    type ChatCancelResponse as ChatCancelResponse,
+    type ChatRespondResponse as ChatRespondResponse,
+    type ChatStreamResponse as ChatStreamResponse,
+    type ChatCreateParams as ChatCreateParams,
+    type ChatReplyToQuestionParams as ChatReplyToQuestionParams,
+    type ChatRespondParams as ChatRespondParams,
+    type ChatSendMessageParams as ChatSendMessageParams,
+    type ChatStreamParams as ChatStreamParams,
+  };
+
+  export {
+    Files as Files,
+    type FileListResponse as FileListResponse,
+    type FileDownloadParams as FileDownloadParams,
+  };
+}

package/src/resources/agent/v2/chat/files.ts

@@ -0,0 +1,63 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../../../core/resource';
+import { APIPromise } from '../../../../core/api-promise';
+import { buildHeaders } from '../../../../internal/headers';
+import { RequestOptions } from '../../../../internal/request-options';
+import { path } from '../../../../internal/utils/path';
+
+/**
+ * Create, manage, and execute AI agents with tool access, sandbox environments, and async run workflows
+ */
+export class Files extends APIResource {
+  /**
+   * Lists files created by the agent in the Daytona runtime workspace. Stopped or
+   * archived runtimes are transparently resumed or recovered.
+   */
+  list(id: string, options?: RequestOptions): APIPromise<FileListResponse> {
+    return this._client.get(path`/agent/v2/chat/${id}/files`, options);
+  }
+
+  /**
+   * Downloads a file from the Daytona runtime workspace by path. Stopped or archived
+   * runtimes are transparently resumed or recovered.
+   */
+  download(filePath: string, params: FileDownloadParams, options?: RequestOptions): APIPromise<Response> {
+    const { id } = params;
+    return this._client.get(path`/agent/v2/chat/${id}/files/${filePath}`, {
+      ...options,
+      headers: buildHeaders([{ Accept: 'application/octet-stream' }, options?.headers]),
+      __binaryResponse: true,
+    });
+  }
+}
+
+export interface FileListResponse {
+  chatId?: string;
+
+  files?: Array<FileListResponse.File>;
+}
+
+export namespace FileListResponse {
+  export interface File {
+    name?: string;
+
+    /**
+     * Relative path from /workspace
+     */
+    path?: string;
+
+    sizeBytes?: number;
+  }
+}
+
+export interface FileDownloadParams {
+  /**
+   * Chat session ID
+   */
+  id: string;
+}
+
+export declare namespace Files {
+  export { type FileListResponse as FileListResponse, type FileDownloadParams as FileDownloadParams };
+}

package/src/resources/agent/v2/chat/index.ts

@@ -0,0 +1,16 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export {
+  Chat,
+  type ChatCreateResponse,
+  type ChatDeleteResponse,
+  type ChatCancelResponse,
+  type ChatRespondResponse,
+  type ChatStreamResponse,
+  type ChatCreateParams,
+  type ChatReplyToQuestionParams,
+  type ChatRespondParams,
+  type ChatSendMessageParams,
+  type ChatStreamParams,
+} from './chat';
+export { Files, type FileListResponse, type FileDownloadParams } from './files';

package/src/resources/agent/v2/chat.ts

@@ -0,0 +1,3 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export * from './chat/index';