@giselles-ai/sandbox-agent-core 0.1.4 → 0.1.6

package/dist/index.d.ts

@@ -1,54 +1,60 @@
 import { z } from 'zod';
-import { RelayRequest, RelayResponse, RelayErrorCode } from '@giselles-ai/browser-tool';
-import Redis from 'ioredis';
+import { Sandbox } from '@vercel/sandbox';
 
-declare const requestSchema: z.ZodObject<{
+type AgentRunnerOptions = {
+    apiKey?: string;
+    baseUrl?: string;
+};
+type AgentRunnerHandler = {
+    POST: (request: Request) => Promise<Response>;
+};
+declare function handleAgentRunner(options?: AgentRunnerOptions): AgentRunnerHandler;
+
+type BaseChatRequest = {
+    message: string;
+    session_id?: string;
+    sandbox_id?: string;
+};
+type ChatCommand = {
+    cmd: string;
+    args: string[];
+    env?: Record<string, string>;
+};
+type ChatAgent<TRequest extends BaseChatRequest> = {
+    requestSchema: z.ZodType<TRequest>;
+    snapshotId?: string;
+    prepareSandbox(input: {
+        input: TRequest;
+        sandbox: Sandbox;
+    }): Promise<void>;
+    createCommand(input: {
+        input: TRequest;
+    }): ChatCommand;
+};
+type RunChatInput<TRequest extends BaseChatRequest> = {
+    agent: ChatAgent<TRequest>;
+    signal: AbortSignal;
+    input: TRequest;
+};
+declare function runChat<TRequest extends BaseChatRequest>(input: RunChatInput<TRequest>): Promise<Response>;
+
+declare const geminiRequestSchema: z.ZodObject<{
     message: z.ZodString;
     session_id: z.ZodOptional<z.ZodString>;
     sandbox_id: z.ZodOptional<z.ZodString>;
-    relay_session_id: z.ZodString;
-    relay_token: z.ZodString;
+    relay_session_id: z.ZodOptional<z.ZodString>;
+    relay_token: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
-type GeminiChatRouteOptions = {
-    requestParser?: typeof requestSchema;
-};
-declare function createGeminiChatHandler(_options?: GeminiChatRouteOptions): (request: Request) => Promise<Response>;
-
-declare function createRelayHandler(): {
-    GET: (request: Request) => Promise<Response>;
-    POST: (request: Request) => Promise<Response>;
+type GeminiAgentRequest = z.infer<typeof geminiRequestSchema>;
+type GeminiAgentOptions = {
+    snapshotId?: string;
+    env?: Record<string, string>;
+    tools?: {
+        browser?: {
+            relayUrl?: string;
+        };
+    };
 };
+declare function createGeminiAgent(options?: GeminiAgentOptions): ChatAgent<GeminiAgentRequest>;
 
-declare const RELAY_SSE_KEEPALIVE_INTERVAL_MS: number;
-declare global {
-    var __browserToolRelayRedis: Redis | undefined;
-}
-declare class RelayStoreError extends Error {
-    readonly code: RelayErrorCode;
-    readonly status: number;
-    constructor(code: RelayErrorCode, message: string, status: number);
-}
-declare function createRelaySubscriber(): Redis;
-declare function relayRequestChannel(sessionId: string): string;
-declare function createRelaySession(): Promise<{
-    sessionId: string;
-    token: string;
-    expiresAt: number;
-}>;
-declare function assertRelaySession(sessionId: string, token: string): Promise<void>;
-declare function markBrowserConnected(sessionId: string, token: string): Promise<void>;
-declare function touchBrowserConnected(sessionId: string): Promise<void>;
-declare function dispatchRelayRequest(input: {
-    sessionId: string;
-    token: string;
-    request: RelayRequest;
-    timeoutMs?: number;
-}): Promise<RelayResponse>;
-declare function resolveRelayResponse(input: {
-    sessionId: string;
-    token: string;
-    response: RelayResponse;
-}): Promise<void>;
-declare function toRelayError(error: unknown): RelayStoreError;
-
-export { RELAY_SSE_KEEPALIVE_INTERVAL_MS, assertRelaySession, createGeminiChatHandler, createRelayHandler, createRelaySession, createRelaySubscriber, dispatchRelayRequest, markBrowserConnected, relayRequestChannel, resolveRelayResponse, toRelayError, touchBrowserConnected };
+export { type AgentRunnerHandler, type AgentRunnerOptions, type BaseChatRequest, type ChatAgent, type ChatCommand, type RunChatInput, createGeminiAgent, handleAgentRunner, runChat };