@giselles-ai/agent 0.1.0-alpha.7 → 0.1.22

package/dist/chunk-K2DPJIHU.js

@@ -0,0 +1,17 @@
+// src/hash.ts
+import { createHash } from "crypto";
+function computeConfigHash(config) {
+  const payload = JSON.stringify({
+    agentType: config.agentType ?? "gemini",
+    agentMd: config.agentMd ?? null,
+    files: (config.files ?? []).map((f) => ({
+      path: f.path,
+      content: f.content
+    }))
+  });
+  return createHash("sha256").update(payload).digest("hex").slice(0, 16);
+}
+
+export {
+  computeConfigHash
+};

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+import { A as AgentConfig, D as DefinedAgent } from './types-Cto-uejG.js';
+export { a as AgentFile } from './types-Cto-uejG.js';
+
+declare function defineAgent(config: AgentConfig): DefinedAgent;
+
+declare function computeConfigHash(config: AgentConfig): string;
+
+export { AgentConfig, DefinedAgent, computeConfigHash, defineAgent };

package/dist/index.js

@@ -0,0 +1,25 @@
+import {
+  computeConfigHash
+} from "./chunk-K2DPJIHU.js";
+
+// src/define-agent.ts
+function defineAgent(config) {
+  return {
+    agentType: config.agentType ?? "gemini",
+    agentMd: config.agentMd,
+    files: config.files ?? [],
+    get snapshotId() {
+      const id = process.env?.GISELLE_AGENT_SNAPSHOT_ID;
+      if (!id) {
+        throw new Error(
+          `GISELLE_AGENT_SNAPSHOT_ID is not set. Ensure withGiselleAgent is configured in next.config.ts.`
+        );
+      }
+      return id;
+    }
+  };
+}
+export {
+  computeConfigHash,
+  defineAgent
+};

package/dist/next/index.d.ts

@@ -0,0 +1,15 @@
+import { NextConfig } from 'next';
+import { A as AgentConfig } from '../types-Cto-uejG.js';
+
+type GiselleAgentPluginOptions = {
+    /** Base URL for the agent API. Default: process.env.GISELLE_AGENT_BASE_URL ?? "https://studio.giselles.ai/agent-api" */
+    baseUrl?: string;
+    /** Bearer token. Default: process.env.GISELLE_AGENT_API_KEY */
+    token?: string;
+    /** Additional headers to include in the build API request */
+    headers?: Record<string, string | undefined>;
+};
+
+declare function withGiselleAgent(nextConfig: NextConfig, agent: AgentConfig, options?: GiselleAgentPluginOptions): () => Promise<NextConfig>;
+
+export { type GiselleAgentPluginOptions, withGiselleAgent };

package/dist/next/index.js

@@ -0,0 +1,82 @@
+import {
+  computeConfigHash
+} from "../chunk-K2DPJIHU.js";
+
+// src/next/with-giselle-agent.ts
+function trimTrailingSlash(url) {
+  return url.replace(/\/+$/, "");
+}
+function withGiselleAgent(nextConfig, agent, options) {
+  return async () => {
+    const baseUrl = trimTrailingSlash(
+      options?.baseUrl ?? process.env.GISELLE_AGENT_BASE_URL ?? "https://studio.giselles.ai/agent-api"
+    );
+    const apiUrl = `${baseUrl}/build`;
+    const token = options?.token ?? process.env.GISELLE_AGENT_API_KEY;
+    if (!token) {
+      console.warn("[withGiselleAgent] Skipped snapshot build: missing token.");
+      return nextConfig;
+    }
+    const configHash = computeConfigHash(agent);
+    const files = [
+      ...agent.files ?? []
+    ];
+    if (agent.agentMd !== void 0) {
+      files.push(
+        {
+          path: "/home/vercel-sandbox/.codex/AGENTS.md",
+          content: agent.agentMd
+        },
+        {
+          path: "/home/vercel-sandbox/.gemini/GEMINI.md",
+          content: agent.agentMd
+        }
+      );
+    }
+    const requestBody = {
+      config_hash: configHash,
+      agent_type: agent.agentType ?? "gemini",
+      files
+    };
+    const requestHeaders = {
+      "content-type": "application/json",
+      authorization: `Bearer ${token}`,
+      ...options?.headers
+    };
+    console.debug("[withGiselleAgent] POST %s", apiUrl);
+    console.debug(
+      "[withGiselleAgent] headers:",
+      JSON.stringify(requestHeaders, null, 2)
+    );
+    console.debug(
+      "[withGiselleAgent] body:",
+      JSON.stringify(requestBody, null, 2)
+    );
+    const response = await fetch(apiUrl, {
+      method: "POST",
+      headers: requestHeaders,
+      body: JSON.stringify(requestBody)
+    });
+    if (!response.ok) {
+      const body = await response.text().catch(() => "");
+      throw new Error(
+        `[withGiselleAgent] Build failed (${response.status}): ${body}`
+      );
+    }
+    const result = await response.json();
+    console.debug(
+      "[withGiselleAgent] result:",
+      JSON.stringify(result, null, 2)
+    );
+    return {
+      ...nextConfig,
+      env: {
+        ...nextConfig.env,
+        GISELLE_AGENT_SNAPSHOT_ID: result.snapshot_id
+      }
+    };
+  };
+}
+export {
+  withGiselleAgent
+};

package/dist/server/index.d.ts

@@ -0,0 +1,254 @@
+import { Sandbox } from '@vercel/sandbox';
+import { z } from 'zod';
+import { RelayRequest, RelayResponse } from '@giselles-ai/browser-tool';
+import { RelayRequestSubscription } from '@giselles-ai/browser-tool/relay';
+
+type AgentType$1 = "codex" | "gemini";
+declare class Agent {
+    private _type;
+    private _snapshotId;
+    private _pendingOps;
+    private constructor();
+    static create(type: AgentType$1, options: {
+        snapshotId: string;
+    }): Agent;
+    get type(): AgentType$1;
+    get snapshotId(): string;
+    get dirty(): boolean;
+    addFiles(files: Array<{
+        path: string;
+        content: Buffer;
+    }>): this;
+    setAgentMd(content: string | Buffer): this;
+    runCommands(commands: Array<{
+        cmd: string;
+        args?: string[];
+    }>): this;
+    prepare(): Promise<void>;
+}
+
+type BaseChatRequest = {
+    message: string;
+    session_id?: string;
+    sandbox_id?: string;
+    snapshot_id?: string;
+};
+type ChatCommand = {
+    cmd: string;
+    args: string[];
+    env?: Record<string, string>;
+};
+type StdoutMapper = {
+    push(chunk: string): string[];
+    flush(): 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;
+    createStdoutMapper?: () => StdoutMapper;
+};
+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 codexRequestSchema: z.ZodObject<{
+    message: z.ZodString;
+    session_id: z.ZodOptional<z.ZodString>;
+    sandbox_id: z.ZodOptional<z.ZodString>;
+    snapshot_id: z.ZodOptional<z.ZodString>;
+    relay_session_id: z.ZodOptional<z.ZodString>;
+    relay_token: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type CodexAgentRequest = z.infer<typeof codexRequestSchema>;
+type CodexAgentOptions = {
+    snapshotId?: string;
+    env?: Record<string, string | undefined>;
+    tools?: {
+        browser?: {
+            relayUrl?: string;
+            relayClient?: {
+                headers?: Record<string, string | undefined>;
+            };
+        };
+    };
+};
+declare function createCodexAgent(options?: CodexAgentOptions): ChatAgent<CodexAgentRequest>;
+
+declare const geminiRequestSchema: z.ZodObject<{
+    message: z.ZodString;
+    session_id: z.ZodOptional<z.ZodString>;
+    sandbox_id: z.ZodOptional<z.ZodString>;
+    snapshot_id: z.ZodOptional<z.ZodString>;
+    relay_session_id: z.ZodOptional<z.ZodString>;
+    relay_token: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type GeminiAgentRequest = z.infer<typeof geminiRequestSchema>;
+type GeminiAgentOptions = {
+    snapshotId?: string;
+    env?: Record<string, string | undefined>;
+    tools?: {
+        browser?: {
+            relayUrl?: string;
+            relayClient?: {
+                headers?: Record<string, string | undefined>;
+            };
+        };
+    };
+};
+declare function createGeminiAgent(options?: GeminiAgentOptions): ChatAgent<GeminiAgentRequest>;
+
+type AgentType = "gemini" | "codex";
+type AgentRequest = BaseChatRequest & {
+    relay_session_id?: string;
+    relay_token?: string;
+};
+type CreateAgentOptions = (GeminiAgentOptions & CodexAgentOptions) & {
+    type: AgentType;
+};
+type AgentParam<TRequest extends BaseChatRequest> = ChatAgent<TRequest> | CreateAgentOptions;
+declare function createAgent(options: CreateAgentOptions): ChatAgent<AgentRequest>;
+
+type CloudToolName = "getFormSnapshot" | "executeFormActions";
+type CloudToolResult = {
+    toolCallId: string;
+    toolName: CloudToolName;
+    output: unknown;
+};
+type CloudChatRequest = BaseChatRequest & {
+    chat_id: string;
+    tool_results?: CloudToolResult[];
+};
+type CloudRelaySession = {
+    sessionId: string;
+    token: string;
+    url: string;
+    expiresAt: number;
+};
+type PendingToolState = {
+    requestId: string;
+    requestType: RelayRequest["type"];
+    toolName: CloudToolName;
+};
+type CloudChatSessionState = {
+    chatId: string;
+    agentSessionId?: string;
+    sandboxId?: string;
+    relay?: CloudRelaySession;
+    pendingTool?: PendingToolState | null;
+    updatedAt: number;
+};
+type CloudChatSessionPatch = {
+    agentSessionId?: string;
+    sandboxId?: string;
+    relay?: CloudRelaySession;
+    pendingTool?: PendingToolState | null;
+};
+interface CloudChatStateStore {
+    load(chatId: string): Promise<CloudChatSessionState | null>;
+    save(state: CloudChatSessionState): Promise<void>;
+    delete(chatId: string): Promise<void>;
+}
+declare function toolNameFromRelayRequest(request: RelayRequest): CloudToolName;
+declare function reduceCloudChatEvent(event: Record<string, unknown>): CloudChatSessionPatch | null;
+declare const cloudChatRunRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"agent.run">;
+    chat_id: z.ZodString;
+    message: z.ZodString;
+    agent_type: z.ZodEnum<{
+        codex: "codex";
+        gemini: "gemini";
+    }>;
+    snapshot_id: z.ZodString;
+    tool_results: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        toolCallId: z.ZodString;
+        toolName: z.ZodEnum<{
+            getFormSnapshot: "getFormSnapshot";
+            executeFormActions: "executeFormActions";
+        }>;
+        output: z.ZodUnknown;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+type CloudChatRunRequest = z.infer<typeof cloudChatRunRequestSchema>;
+declare function applyCloudChatPatch(input: {
+    chatId: string;
+    now: number;
+    base?: CloudChatSessionState | null;
+    patch?: CloudChatSessionPatch | null;
+}): CloudChatSessionState;
+
+type AgentApiStoreConfig = {
+    adapter: "redis";
+    url?: string;
+};
+
+type BeforeHook = (request: Request) => Response | undefined | Promise<Response | undefined>;
+type AgentApiOptions = {
+    basePath: string;
+    store: AgentApiStoreConfig;
+    agent: Omit<CreateAgentOptions, "type" | "snapshotId">;
+    build?: {
+        baseSnapshotId?: string;
+    };
+    hooks?: {
+        chat?: {
+            before?: BeforeHook;
+        };
+        build?: {
+            before?: BeforeHook;
+        };
+    };
+};
+
+declare function createAgentApi(options: AgentApiOptions): {
+    GET: (request: Request) => Promise<Response>;
+    POST: (request: Request) => Promise<Response>;
+    OPTIONS: (request: Request) => Response;
+};
+
+type CodexStdoutMapper = {
+    push(chunk: string): string[];
+    flush(): string[];
+};
+declare function createCodexStdoutMapper(): CodexStdoutMapper;
+
+type RelaySessionFactoryResult = {
+    sessionId: string;
+    token: string;
+    expiresAt: number;
+};
+type RunChatImpl<TRequest extends BaseChatRequest> = (input: RunChatInput<TRequest>) => Promise<Response>;
+declare function runCloudChat<TRequest extends CloudChatRequest & {
+    relay_session_id?: string;
+    relay_token?: string;
+}>(input: {
+    chatId: string;
+    request: Omit<TRequest, "session_id" | "sandbox_id" | "relay_session_id" | "relay_token">;
+    agent: AgentParam<TRequest>;
+    signal: AbortSignal;
+    relayUrl: string;
+    store: CloudChatStateStore;
+    createRelaySession: () => Promise<RelaySessionFactoryResult>;
+    runChatImpl?: RunChatImpl<TRequest>;
+    now?: () => number;
+    createRelayRequestSubscription?: (input: {
+        sessionId: string;
+        token: string;
+    }) => Promise<RelayRequestSubscription>;
+    sendRelayResponse?: (input: {
+        sessionId: string;
+        token: string;
+        response: RelayResponse;
+    }) => Promise<void>;
+}): Promise<Response>;
+
+export { Agent, type AgentApiOptions, type AgentApiStoreConfig, type AgentParam, type AgentRequest, type AgentType, type BaseChatRequest, type ChatAgent, type ChatCommand, type CloudChatRequest, type CloudChatRunRequest, type CloudChatSessionPatch, type CloudChatSessionState, type CloudChatStateStore, type CloudRelaySession, type CloudToolName, type CloudToolResult, type CreateAgentOptions, type PendingToolState, type RelaySessionFactoryResult, type RunChatImpl, type RunChatInput, type StdoutMapper, applyCloudChatPatch, cloudChatRunRequestSchema, createAgent, createAgentApi, createCodexAgent, createCodexStdoutMapper, createGeminiAgent, reduceCloudChatEvent, runChat, runCloudChat, toolNameFromRelayRequest };