casedev 0.31.3 → 0.32.0

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';

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

@@ -0,0 +1,67 @@
+// 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 { RequestOptions } from '../../../internal/request-options';
+
+/**
+ * Create, manage, and execute AI agents with tool access, sandbox environments, and async run workflows
+ */
+export class Execute extends APIResource {
+  /**
+   * Creates an ephemeral agent and immediately executes a v2 run on the Daytona
+   * runtime.
+   */
+  create(body: ExecuteCreateParams, options?: RequestOptions): APIPromise<ExecuteCreateResponse> {
+    return this._client.post('/agent/v2/execute', { body, ...options });
+  }
+}
+
+export interface ExecuteCreateResponse {
+  agentId?: string;
+
+  message?: string;
+
+  provider?: 'daytona';
+
+  runId?: string;
+
+  runtimeState?: 'running';
+
+  status?: 'running';
+}
+
+export interface ExecuteCreateParams {
+  prompt: string;
+
+  disabledTools?: Array<string> | null;
+
+  enabledTools?: Array<string> | null;
+
+  guidance?: string | null;
+
+  instructions?: string;
+
+  model?: string;
+
+  objectIds?: Array<string> | null;
+
+  sandbox?: ExecuteCreateParams.Sandbox | null;
+
+  vaultIds?: Array<string> | null;
+}
+
+export namespace ExecuteCreateParams {
+  export interface Sandbox {
+    cpu?: number;
+
+    memoryMiB?: number;
+  }
+}
+
+export declare namespace Execute {
+  export {
+    type ExecuteCreateResponse as ExecuteCreateResponse,
+    type ExecuteCreateParams as ExecuteCreateParams,
+  };
+}

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

@@ -0,0 +1,27 @@
+// 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/index';
+export { Execute, type ExecuteCreateResponse, type ExecuteCreateParams } from './execute';
+export {
+  Run,
+  type RunCreateResponse,
+  type RunEventsResponse,
+  type RunExecResponse,
+  type RunGetDetailsResponse,
+  type RunGetStatusResponse,
+  type RunCreateParams,
+  type RunEventsParams,
+} from './run';
+export { V2 } from './v2';

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

@@ -0,0 +1,137 @@
+// 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 { 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 Run extends APIResource {
+  /**
+   * Creates a v2 run in queued state. Call POST /agent/v2/run/:id/exec to start
+   * execution on the Daytona runtime.
+   */
+  create(body: RunCreateParams, options?: RequestOptions): APIPromise<RunCreateResponse> {
+    return this._client.post('/agent/v2/run', { body, ...options });
+  }
+
+  /**
+   * Streams real-time v2 run events over SSE with replay support.
+   */
+  events(
+    id: string,
+    query: RunEventsParams | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<Stream<RunEventsResponse>> {
+    return this._client.get(path`/agent/v2/run/${id}/events`, {
+      query,
+      ...options,
+      headers: buildHeaders([{ Accept: 'text/event-stream' }, options?.headers]),
+      stream: true,
+    }) as APIPromise<Stream<RunEventsResponse>>;
+  }
+
+  /**
+   * Starts execution of a queued v2 run. The agent runs in a durable workflow on a
+   * Daytona runtime.
+   */
+  exec(id: string, options?: RequestOptions): APIPromise<RunExecResponse> {
+    return this._client.post(path`/agent/v2/run/${id}/exec`, options);
+  }
+
+  /**
+   * Full audit trail for a v2 run, with provider-neutral runtime metadata.
+   */
+  getDetails(id: string, options?: RequestOptions): APIPromise<unknown> {
+    return this._client.get(path`/agent/v2/run/${id}/details`, options);
+  }
+
+  /**
+   * Lightweight status poll for a v2 run including neutral runtime metadata.
+   */
+  getStatus(id: string, options?: RequestOptions): APIPromise<RunGetStatusResponse> {
+    return this._client.get(path`/agent/v2/run/${id}/status`, options);
+  }
+}
+
+export interface RunCreateResponse {
+  id?: string;
+
+  agentId?: string;
+
+  createdAt?: string;
+
+  objectIds?: Array<string> | null;
+
+  status?: 'queued';
+}
+
+export type RunEventsResponse = string;
+
+export interface RunExecResponse {
+  id?: string;
+
+  message?: string;
+
+  provider?: 'daytona';
+
+  runtimeState?: 'running';
+
+  status?: 'running';
+
+  workflowId?: string;
+}
+
+export type RunGetDetailsResponse = unknown;
+
+export interface RunGetStatusResponse {
+  id?: string;
+
+  completedAt?: string | null;
+
+  durationMs?: number | null;
+
+  provider?: string | null;
+
+  runtimeId?: string | null;
+
+  runtimeState?: string | null;
+
+  startedAt?: string | null;
+
+  status?: 'queued' | 'running' | 'completed' | 'failed' | 'cancelled';
+}
+
+export interface RunCreateParams {
+  agentId: string;
+
+  prompt: string;
+
+  callbackUrl?: string | null;
+
+  guidance?: string | null;
+
+  model?: string | null;
+
+  objectIds?: Array<string> | null;
+}
+
+export interface RunEventsParams {
+  lastEventId?: number;
+}
+
+export declare namespace Run {
+  export {
+    type RunCreateResponse as RunCreateResponse,
+    type RunEventsResponse as RunEventsResponse,
+    type RunExecResponse as RunExecResponse,
+    type RunGetDetailsResponse as RunGetDetailsResponse,
+    type RunGetStatusResponse as RunGetStatusResponse,
+    type RunCreateParams as RunCreateParams,
+    type RunEventsParams as RunEventsParams,
+  };
+}

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

@@ -0,0 +1,73 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../../core/resource';
+import * as ExecuteAPI from './execute';
+import { Execute, ExecuteCreateParams, ExecuteCreateResponse } from './execute';
+import * as RunAPI from './run';
+import {
+  Run,
+  RunCreateParams,
+  RunCreateResponse,
+  RunEventsParams,
+  RunEventsResponse,
+  RunExecResponse,
+  RunGetDetailsResponse,
+  RunGetStatusResponse,
+} from './run';
+import * as ChatAPI from './chat/chat';
+import {
+  Chat,
+  ChatCancelResponse,
+  ChatCreateParams,
+  ChatCreateResponse,
+  ChatDeleteResponse,
+  ChatReplyToQuestionParams,
+  ChatRespondParams,
+  ChatRespondResponse,
+  ChatSendMessageParams,
+  ChatStreamParams,
+  ChatStreamResponse,
+} from './chat/chat';
+
+export class V2 extends APIResource {
+  run: RunAPI.Run = new RunAPI.Run(this._client);
+  execute: ExecuteAPI.Execute = new ExecuteAPI.Execute(this._client);
+  chat: ChatAPI.Chat = new ChatAPI.Chat(this._client);
+}
+
+V2.Run = Run;
+V2.Execute = Execute;
+V2.Chat = Chat;
+
+export declare namespace V2 {
+  export {
+    Run as Run,
+    type RunCreateResponse as RunCreateResponse,
+    type RunEventsResponse as RunEventsResponse,
+    type RunExecResponse as RunExecResponse,
+    type RunGetDetailsResponse as RunGetDetailsResponse,
+    type RunGetStatusResponse as RunGetStatusResponse,
+    type RunCreateParams as RunCreateParams,
+    type RunEventsParams as RunEventsParams,
+  };
+
+  export {
+    Execute as Execute,
+    type ExecuteCreateResponse as ExecuteCreateResponse,
+    type ExecuteCreateParams as ExecuteCreateParams,
+  };
+
+  export {
+    Chat as Chat,
+    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,
+  };
+}

package/src/resources/agent/v2.ts

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

package/src/resources/vault/objects.ts

@@ -254,6 +254,11 @@ export interface ObjectRetrieveResponse {
    */
   chunkCount?: number;
 
+  /**
+   * Error details when ingestion fails
+   */
+  ingestionError?: string | null;
+
   /**
    * Additional metadata
    */

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = '0.31.3'; // x-release-please-version
+export const VERSION = '0.32.0'; // x-release-please-version

package/version.d.mts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.31.3";
+export declare const VERSION = "0.32.0";
 //# sourceMappingURL=version.d.mts.map

package/version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.31.3";
+export declare const VERSION = "0.32.0";
 //# sourceMappingURL=version.d.ts.map