@finalai/agents 0.11.0 → 0.13.0

package/dist/modules/agent-client/local-host-protocol.d.mts

@@ -0,0 +1,156 @@
+import { Capability } from '@finalai/agent-protocol';
+import { jsonValueSchema } from '@finalai/agent-provider/json';
+import { CodeLineType } from '@finalai/agent-provider/code-host';
+import type { FrameChannelIface, WireFrame } from '@finalai/agent-provider/sandbox/wire';
+import * as z from 'zod';
+export declare const LOCAL_HOST_PROTOCOL_VERSION = 1;
+export declare const LOCAL_HOST_SUBPROTOCOL = "final.local-host.v1";
+export declare const LOCAL_HOST_REQUEST_ID_PREFIX = "host:";
+export declare const localHostPath: (projectId: string) => string;
+export declare enum LocalHostMethod {
+    Hello = "host/hello",
+    CodeRun = "code/run",
+    CodeProgress = "code/progress",
+    CodeSecret = "code/secret"
+}
+export declare const CANCEL_REQUEST_METHOD = "$/cancel_request";
+export declare enum LocalHostOwnerKind {
+    Session = "session",
+    Conversation = "conversation"
+}
+export declare const localHostOwnerSchema: z.ZodObject<{
+    kind: z.ZodEnum<typeof LocalHostOwnerKind>;
+    id: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type LocalHostOwnerIface = z.input<typeof localHostOwnerSchema>;
+export declare const localHostHelloParamsSchema: z.ZodObject<{
+    protocolVersion: z.ZodLiteral<1>;
+    owner: z.ZodObject<{
+        kind: z.ZodEnum<typeof LocalHostOwnerKind>;
+        id: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    agent: z.ZodString;
+    capabilities: z.ZodArray<z.ZodEnum<typeof Capability>>;
+    tools: z.ZodArray<z.ZodString>;
+    hooks: z.ZodArray<z.ZodString>;
+    approvals: z.ZodArray<z.ZodString>;
+    resume: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type LocalHostHelloParamsIface = z.input<typeof localHostHelloParamsSchema>;
+export declare const localHostHelloResultSchema: z.ZodObject<{
+    hostId: z.ZodString;
+    owner: z.ZodObject<{
+        kind: z.ZodString;
+        id: z.ZodString;
+    }, z.core.$strip>;
+    sandboxId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type LocalHostHelloResultIface = z.infer<typeof localHostHelloResultSchema>;
+export declare const localHostCodeRunParamsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<import("@finalai/agent-provider").CodeKind.Tool>;
+    name: z.ZodString;
+    input: z.ZodType<import("@finalai/agent-provider").JsonValue, unknown, z.core.$ZodTypeInternals<import("@finalai/agent-provider").JsonValue, unknown>>;
+    context: z.ZodObject<{
+        sessionId: z.ZodNullable<z.ZodString>;
+        callId: z.ZodString;
+        actingUserId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        compute: z.ZodDefault<z.ZodRecord<z.ZodEnum<typeof Capability> & z.core.$partial, z.ZodObject<{
+            url: z.ZodString;
+            token: z.ZodString;
+            expiresAt: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<import("@finalai/agent-provider").CodeKind.Hook>;
+    name: z.ZodString;
+    event: z.ZodString;
+    payload: z.ZodType<import("@finalai/agent-provider").JsonValue, unknown, z.core.$ZodTypeInternals<import("@finalai/agent-provider").JsonValue, unknown>>;
+    context: z.ZodObject<{
+        sessionId: z.ZodNullable<z.ZodString>;
+        callId: z.ZodString;
+        actingUserId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        compute: z.ZodDefault<z.ZodRecord<z.ZodEnum<typeof Capability> & z.core.$partial, z.ZodObject<{
+            url: z.ZodString;
+            token: z.ZodString;
+            expiresAt: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<import("@finalai/agent-provider").CodeKind.Approval>;
+    name: z.ZodString;
+    input: z.ZodType<import("@finalai/agent-provider").JsonValue, unknown, z.core.$ZodTypeInternals<import("@finalai/agent-provider").JsonValue, unknown>>;
+    context: z.ZodObject<{
+        sessionId: z.ZodNullable<z.ZodString>;
+        callId: z.ZodString;
+        actingUserId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        compute: z.ZodDefault<z.ZodRecord<z.ZodEnum<typeof Capability> & z.core.$partial, z.ZodObject<{
+            url: z.ZodString;
+            token: z.ZodString;
+            expiresAt: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+}, z.core.$strip>], "kind">;
+export declare const localHostCodeProgressParamsSchema: z.ZodObject<{
+    requestId: z.ZodString;
+    data: z.ZodType<import("@finalai/agent-provider").JsonValue, unknown, z.core.$ZodTypeInternals<import("@finalai/agent-provider").JsonValue, unknown>>;
+    label: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const localHostSecretParamsSchema: z.ZodObject<{
+    requestId: z.ZodString;
+    name: z.ZodString;
+}, z.core.$strict>;
+export declare const localHostSecretResultSchema: z.ZodObject<{
+    value: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const localHostCodeResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<CodeLineType.Result>;
+    output: z.ZodType<import("@finalai/agent-provider").JsonValue, unknown, z.core.$ZodTypeInternals<import("@finalai/agent-provider").JsonValue, unknown>>;
+    modelOutput: z.ZodOptional<z.ZodType<import("@finalai/agent-provider").JsonValue, unknown, z.core.$ZodTypeInternals<import("@finalai/agent-provider").JsonValue, unknown>>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<CodeLineType.Error>;
+    message: z.ZodString;
+}, z.core.$strip>], "type">;
+export type LocalHostCodeResultIface = z.infer<typeof localHostCodeResultSchema>;
+/** Whether a frame on the shared socket belongs to the host protocol. */
+export declare const isHostFrame: (frame: WireFrame) => boolean;
+export interface LocalHostChannelsIface {
+    sandbox: FrameChannelIface;
+    host: FrameChannelIface;
+}
+/**
+ * Splits the shared socket into the sandbox wire and the host protocol. Both
+ * sides of the connection use it; closing either closes the socket.
+ */
+export declare const splitLocalHostChannel: (socket: FrameChannelIface) => LocalHostChannelsIface;
+export interface HostRequestContextIface {
+    id: string;
+    params: z.output<typeof jsonValueSchema> | undefined;
+    signal: AbortSignal;
+}
+export interface HostPeerIface {
+    request: (method: string, params: z.input<typeof jsonValueSchema>) => Promise<unknown>;
+    notify: (method: string, params: z.input<typeof jsonValueSchema>) => void;
+    close: (code?: number, reason?: string) => void;
+    /** Resolves when the socket closes, for any reason. */
+    closed: Promise<{
+        code: number;
+        reason: string;
+    }>;
+    isClosed: () => boolean;
+}
+export declare enum HostRpcErrorCode {
+    MethodNotFound = -32601,
+    InvalidParams = -32602,
+    Internal = -32603,
+    Cancelled = -32800
+}
+/**
+ * JSON-RPC 2.0 for the host protocol. Ids it sends are strings starting with
+ * `host:`, so the far side routes their responses (see `isHostFrame`).
+ */
+export declare const createHostPeer: (args: {
+    channel: FrameChannelIface;
+    onRequest?: (method: string, context: HostRequestContextIface) => Promise<unknown>;
+    onNotification?: (method: string, params: z.output<typeof jsonValueSchema> | undefined) => void;
+    newId?: () => string;
+}) => HostPeerIface;

package/dist/modules/agent-client/local-host-protocol.mjs

@@ -0,0 +1,258 @@
+import { Capability } from "@finalai/agent-protocol";
+import { jsonValueSchema } from "@finalai/agent-provider/json";
+import { codeInvocationSchema, CodeLineType } from "@finalai/agent-provider/code-host";
+import * as z from "zod";
+const LOCAL_HOST_PROTOCOL_VERSION = 1;
+const LOCAL_HOST_SUBPROTOCOL = "final.local-host.v1";
+const LOCAL_HOST_REQUEST_ID_PREFIX = "host:";
+const localHostPath = (projectId) => `/v1/projects/${encodeURIComponent(projectId)}/local-hosts`;
+var LocalHostMethod = /* @__PURE__ */ ((LocalHostMethod2) => {
+  LocalHostMethod2["Hello"] = "host/hello";
+  LocalHostMethod2["CodeRun"] = "code/run";
+  LocalHostMethod2["CodeProgress"] = "code/progress";
+  LocalHostMethod2["CodeSecret"] = "code/secret";
+  return LocalHostMethod2;
+})(LocalHostMethod || {});
+const CANCEL_REQUEST_METHOD = "$/cancel_request";
+var LocalHostOwnerKind = /* @__PURE__ */ ((LocalHostOwnerKind2) => {
+  LocalHostOwnerKind2["Session"] = "session";
+  LocalHostOwnerKind2["Conversation"] = "conversation";
+  return LocalHostOwnerKind2;
+})(LocalHostOwnerKind || {});
+const localHostOwnerSchema = z.strictObject({
+  kind: z.nativeEnum(LocalHostOwnerKind),
+  // Absent: the platform reserves a new id the client then creates with.
+  id: z.string().min(1).max(200).optional()
+});
+const localHostHelloParamsSchema = z.strictObject({
+  protocolVersion: z.literal(LOCAL_HOST_PROTOCOL_VERSION),
+  // The session or conversation the agent runs in.
+  owner: localHostOwnerSchema,
+  // The agent's content hash; its document is stored before or with the create call.
+  agent: z.string().min(1),
+  // Capabilities served from this process; empty when it only answers code.
+  capabilities: z.array(z.nativeEnum(Capability)),
+  // In-process code this process answers, by its name in the document.
+  tools: z.array(z.string()),
+  hooks: z.array(z.string()),
+  approvals: z.array(z.string()),
+  // A host id from an earlier connection, to resume after a disconnect.
+  resume: z.string().min(1).optional()
+});
+const localHostHelloResultSchema = z.object({
+  hostId: z.string(),
+  owner: z.object({ kind: z.string(), id: z.string() }),
+  // The sandbox id that names this process's compute in `provide.compute`;
+  // null when no capability is served.
+  sandboxId: z.string().nullable().default(null)
+});
+const localHostCodeRunParamsSchema = codeInvocationSchema;
+const localHostCodeProgressParamsSchema = z.strictObject({
+  requestId: z.string(),
+  data: jsonValueSchema,
+  label: z.string().optional()
+});
+const localHostSecretParamsSchema = z.strictObject({
+  requestId: z.string(),
+  name: z.string().min(1)
+});
+const localHostSecretResultSchema = z.object({
+  // Null when the project has no such secret set.
+  value: z.string().nullable()
+});
+const localHostCodeResultSchema = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal(CodeLineType.Result),
+    output: jsonValueSchema,
+    modelOutput: jsonValueSchema.optional()
+  }),
+  z.object({ type: z.literal(CodeLineType.Error), message: z.string() })
+]);
+const textFrameSchema = z.looseObject({
+  method: z.string().optional(),
+  id: z.union([z.string(), z.number(), z.null()]).optional(),
+  params: z.looseObject({ requestId: z.union([z.string(), z.number()]).optional() }).optional()
+});
+const isHostId = (id) => typeof id === "string" && id.startsWith(LOCAL_HOST_REQUEST_ID_PREFIX);
+const isHostFrame = (frame) => {
+  if (typeof frame !== "string") return false;
+  let raw;
+  try {
+    raw = JSON.parse(frame);
+  } catch {
+    return false;
+  }
+  const message = textFrameSchema.safeParse(raw);
+  if (!message.success) return false;
+  const method = message.data.method;
+  if (method === CANCEL_REQUEST_METHOD) return isHostId(message.data.params?.requestId);
+  if (method != null) return method.startsWith("host/") || method.startsWith("code/");
+  return isHostId(message.data.id);
+};
+const splitLocalHostChannel = (socket) => {
+  const make = () => {
+    let handlers = null;
+    const pending = [];
+    let closed = null;
+    const channel = {
+      send: (frame) => socket.send(frame),
+      close: (code, reason) => socket.close(code, reason),
+      listen: (next) => {
+        handlers = next;
+        for (const frame of pending.splice(0)) next.frame(frame);
+        if (closed != null) next.close(closed);
+      }
+    };
+    return {
+      channel,
+      frame: (frame) => {
+        if (handlers == null) pending.push(frame);
+        else handlers.frame(frame);
+      },
+      close: (info) => {
+        if (closed != null) return;
+        closed = info;
+        handlers?.close(info);
+      }
+    };
+  };
+  const sandbox = make();
+  const host = make();
+  socket.listen({
+    frame: (frame) => (isHostFrame(frame) ? host : sandbox).frame(frame),
+    close: (info) => {
+      sandbox.close(info);
+      host.close(info);
+    }
+  });
+  return { sandbox: sandbox.channel, host: host.channel };
+};
+const hostMessageSchema = z.looseObject({
+  method: z.string().optional(),
+  id: z.union([z.string(), z.number(), z.null()]).optional(),
+  params: jsonValueSchema.optional(),
+  result: jsonValueSchema.optional(),
+  error: z.looseObject({ code: z.number(), message: z.string() }).optional()
+});
+const cancelParamsSchema = z.object({ requestId: z.string() });
+var HostRpcErrorCode = /* @__PURE__ */ ((HostRpcErrorCode2) => {
+  HostRpcErrorCode2[HostRpcErrorCode2["MethodNotFound"] = -32601] = "MethodNotFound";
+  HostRpcErrorCode2[HostRpcErrorCode2["InvalidParams"] = -32602] = "InvalidParams";
+  HostRpcErrorCode2[HostRpcErrorCode2["Internal"] = -32603] = "Internal";
+  HostRpcErrorCode2[HostRpcErrorCode2["Cancelled"] = -32800] = "Cancelled";
+  return HostRpcErrorCode2;
+})(HostRpcErrorCode || {});
+const createHostPeer = (args) => {
+  let counter = 0;
+  const newId = args.newId ?? (() => `${LOCAL_HOST_REQUEST_ID_PREFIX}${++counter}`);
+  const pending = /* @__PURE__ */ new Map();
+  const inbound = /* @__PURE__ */ new Map();
+  let closedInfo = null;
+  let resolveClosed = () => void 0;
+  const closed = new Promise((resolve) => {
+    resolveClosed = resolve;
+  });
+  const send = (message) => {
+    if (closedInfo == null) args.channel.send(JSON.stringify({ jsonrpc: "2.0", ...message }));
+  };
+  const answer = async (method, id, params) => {
+    const controller = new AbortController();
+    inbound.set(id, controller);
+    try {
+      const handler = args.onRequest;
+      if (handler == null) {
+        send({ id, error: { code: -32601 /* MethodNotFound */, message: method } });
+        return;
+      }
+      const result = await handler(method, { id, params, signal: controller.signal });
+      send(
+        controller.signal.aborted ? { id, error: { code: -32800 /* Cancelled */, message: "request cancelled" } } : { id, result: result ?? {} }
+      );
+    } catch (cause) {
+      send({
+        id,
+        error: {
+          code: -32603 /* Internal */,
+          message: cause instanceof Error ? cause.message : String(cause)
+        }
+      });
+    } finally {
+      inbound.delete(id);
+    }
+  };
+  args.channel.listen({
+    frame: (frame) => {
+      if (typeof frame !== "string") return;
+      let raw;
+      try {
+        raw = JSON.parse(frame);
+      } catch {
+        return;
+      }
+      const message = hostMessageSchema.safeParse(raw);
+      if (!message.success) return;
+      const { method, id } = message.data;
+      if (method === CANCEL_REQUEST_METHOD) {
+        const cancel = cancelParamsSchema.safeParse(message.data.params);
+        if (cancel.success) inbound.get(cancel.data.requestId)?.abort();
+        return;
+      }
+      if (method != null) {
+        if (id == null) args.onNotification?.(method, message.data.params);
+        else void answer(method, String(id), message.data.params);
+        return;
+      }
+      if (typeof id !== "string") return;
+      const waiter = pending.get(id);
+      if (waiter == null) return;
+      pending.delete(id);
+      if (message.data.error != null) waiter.reject(new Error(message.data.error.message));
+      else waiter.resolve(message.data.result ?? null);
+    },
+    close: (info) => {
+      if (closedInfo != null) return;
+      closedInfo = info;
+      for (const controller of inbound.values()) controller.abort();
+      for (const waiter of pending.values())
+        waiter.reject(new Error(`local host connection closed (${info.code})`));
+      pending.clear();
+      resolveClosed(info);
+    }
+  });
+  return {
+    request: (method, params) => {
+      if (closedInfo != null) return Promise.reject(new Error("local host connection is closed"));
+      const id = newId();
+      return new Promise((resolve, reject) => {
+        pending.set(id, { resolve, reject });
+        send({ id, method, params });
+      });
+    },
+    notify: (method, params) => send({ method, params }),
+    close: (code, reason) => args.channel.close(code, reason),
+    closed,
+    isClosed: () => closedInfo != null
+  };
+};
+export {
+  CANCEL_REQUEST_METHOD,
+  HostRpcErrorCode,
+  LOCAL_HOST_PROTOCOL_VERSION,
+  LOCAL_HOST_REQUEST_ID_PREFIX,
+  LOCAL_HOST_SUBPROTOCOL,
+  LocalHostMethod,
+  LocalHostOwnerKind,
+  createHostPeer,
+  isHostFrame,
+  localHostCodeProgressParamsSchema,
+  localHostCodeResultSchema,
+  localHostCodeRunParamsSchema,
+  localHostHelloParamsSchema,
+  localHostHelloResultSchema,
+  localHostOwnerSchema,
+  localHostPath,
+  localHostSecretParamsSchema,
+  localHostSecretResultSchema,
+  splitLocalHostChannel
+};
+//# sourceMappingURL=local-host-protocol.mjs.map

package/dist/modules/agent-client/local-host-protocol.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/agent-client/local-host-protocol.ts"],
+  "sourcesContent": ["import { Capability } from '@finalai/agent-protocol';\nimport { jsonValueSchema } from '@finalai/agent-provider/json';\nimport { codeInvocationSchema, CodeLineType } from '@finalai/agent-provider/code-host';\nimport type { FrameChannelIface, WireFrame } from '@finalai/agent-provider/sandbox/wire';\nimport * as z from 'zod';\n\n// The connection a client dials so the platform can use its process: a\n// WebSocket to `/api/v1/projects/:projectId/local-hosts`, one per agent it\n// started. On it the client serves the agent's `files` and `shell` with the\n// sandbox handle RPC (`@finalai/agent-provider/sandbox/wire`, the platform\n// being the RPC client) and answers calls to the agent's in-process tools,\n// hooks and approval predicates with the small JSON-RPC below. HOSTING.md\n// documents both directions.\n//\n// Both kinds of message share one socket. Binary frames are always the\n// sandbox wire's stream chunks. A text frame belongs to the host protocol when\n// it is a request or notification whose method starts with `host/` or `code/`,\n// or a response (or `$/cancel_request`) whose id is a string starting with\n// `host:`; every other frame is the sandbox wire's, whose ids are numbers.\n\nexport const LOCAL_HOST_PROTOCOL_VERSION = 1;\nexport const LOCAL_HOST_SUBPROTOCOL = 'final.local-host.v1';\nexport const LOCAL_HOST_REQUEST_ID_PREFIX = 'host:';\n\nexport const localHostPath = (projectId: string): string =>\n  `/v1/projects/${encodeURIComponent(projectId)}/local-hosts`;\n\nexport enum LocalHostMethod {\n  // Client \u2192 platform, first on every connection.\n  Hello = 'host/hello',\n  // Platform \u2192 client: run one in-process tool, hook or approval predicate.\n  CodeRun = 'code/run',\n  // Client \u2192 platform notification: progress of a running `code/run`.\n  CodeProgress = 'code/progress',\n  // Client \u2192 platform: a project secret for a running `code/run`.\n  CodeSecret = 'code/secret',\n}\n\nexport const CANCEL_REQUEST_METHOD = '$/cancel_request';\n\nexport enum LocalHostOwnerKind {\n  Session = 'session',\n  Conversation = 'conversation',\n}\n\nexport const localHostOwnerSchema = z.strictObject({\n  kind: z.nativeEnum(LocalHostOwnerKind),\n  // Absent: the platform reserves a new id the client then creates with.\n  id: z.string().min(1).max(200).optional(),\n});\n\nexport type LocalHostOwnerIface = z.input<typeof localHostOwnerSchema>;\n\nexport const localHostHelloParamsSchema = z.strictObject({\n  protocolVersion: z.literal(LOCAL_HOST_PROTOCOL_VERSION),\n  // The session or conversation the agent runs in.\n  owner: localHostOwnerSchema,\n  // The agent's content hash; its document is stored before or with the create call.\n  agent: z.string().min(1),\n  // Capabilities served from this process; empty when it only answers code.\n  capabilities: z.array(z.nativeEnum(Capability)),\n  // In-process code this process answers, by its name in the document.\n  tools: z.array(z.string()),\n  hooks: z.array(z.string()),\n  approvals: z.array(z.string()),\n  // A host id from an earlier connection, to resume after a disconnect.\n  resume: z.string().min(1).optional(),\n});\n\nexport type LocalHostHelloParamsIface = z.input<typeof localHostHelloParamsSchema>;\n\nexport const localHostHelloResultSchema = z.object({\n  hostId: z.string(),\n  owner: z.object({ kind: z.string(), id: z.string() }),\n  // The sandbox id that names this process's compute in `provide.compute`;\n  // null when no capability is served.\n  sandboxId: z.string().nullable().default(null),\n});\n\nexport type LocalHostHelloResultIface = z.infer<typeof localHostHelloResultSchema>;\n\nexport const localHostCodeRunParamsSchema = codeInvocationSchema;\n\nexport const localHostCodeProgressParamsSchema = z.strictObject({\n  requestId: z.string(),\n  data: jsonValueSchema,\n  label: z.string().optional(),\n});\n\n// `code/secret`: one secret the agent's document lists, read for the running\n// `code/run` request `requestId`; the platform resolves it in the project of\n// the session or conversation the host serves.\nexport const localHostSecretParamsSchema = z.strictObject({\n  requestId: z.string(),\n  name: z.string().min(1),\n});\n\nexport const localHostSecretResultSchema = z.object({\n  // Null when the project has no such secret set.\n  value: z.string().nullable(),\n});\n\n// The `code/run` result: the invocation's final line.\nexport const localHostCodeResultSchema = z.discriminatedUnion('type', [\n  z.object({\n    type: z.literal(CodeLineType.Result),\n    output: jsonValueSchema,\n    modelOutput: jsonValueSchema.optional(),\n  }),\n  z.object({ type: z.literal(CodeLineType.Error), message: z.string() }),\n]);\n\nexport type LocalHostCodeResultIface = z.infer<typeof localHostCodeResultSchema>;\n\nconst textFrameSchema = z.looseObject({\n  method: z.string().optional(),\n  id: z.union([z.string(), z.number(), z.null()]).optional(),\n  params: z.looseObject({ requestId: z.union([z.string(), z.number()]).optional() }).optional(),\n});\n\nconst isHostId = (id: unknown): boolean =>\n  typeof id === 'string' && id.startsWith(LOCAL_HOST_REQUEST_ID_PREFIX);\n\n/** Whether a frame on the shared socket belongs to the host protocol. */\nexport const isHostFrame = (frame: WireFrame): boolean => {\n  if (typeof frame !== 'string') return false;\n  let raw: unknown;\n  try {\n    raw = JSON.parse(frame);\n  } catch {\n    return false;\n  }\n  const message = textFrameSchema.safeParse(raw);\n  if (!message.success) return false;\n  const method = message.data.method;\n  if (method === CANCEL_REQUEST_METHOD) return isHostId(message.data.params?.requestId);\n  if (method != null) return method.startsWith('host/') || method.startsWith('code/');\n  return isHostId(message.data.id);\n};\n\nexport interface LocalHostChannelsIface {\n  // The sandbox handle RPC's frames.\n  sandbox: FrameChannelIface;\n  // The host protocol's frames.\n  host: FrameChannelIface;\n}\n\n/**\n * Splits the shared socket into the sandbox wire and the host protocol. Both\n * sides of the connection use it; closing either closes the socket.\n */\nexport const splitLocalHostChannel = (socket: FrameChannelIface): LocalHostChannelsIface => {\n  type Handlers = Parameters<FrameChannelIface['listen']>[0];\n  const make = () => {\n    let handlers: Handlers | null = null;\n    const pending: WireFrame[] = [];\n    let closed: { code: number; reason: string } | null = null;\n    const channel: FrameChannelIface = {\n      send: (frame) => socket.send(frame),\n      close: (code, reason) => socket.close(code, reason),\n      listen: (next) => {\n        handlers = next;\n        for (const frame of pending.splice(0)) next.frame(frame);\n        if (closed != null) next.close(closed);\n      },\n    };\n    return {\n      channel,\n      frame: (frame: WireFrame) => {\n        if (handlers == null) pending.push(frame);\n        else handlers.frame(frame);\n      },\n      close: (info: { code: number; reason: string }) => {\n        if (closed != null) return;\n        closed = info;\n        handlers?.close(info);\n      },\n    };\n  };\n  const sandbox = make();\n  const host = make();\n  socket.listen({\n    frame: (frame) => (isHostFrame(frame) ? host : sandbox).frame(frame),\n    close: (info) => {\n      sandbox.close(info);\n      host.close(info);\n    },\n  });\n  return { sandbox: sandbox.channel, host: host.channel };\n};\n\nconst hostMessageSchema = z.looseObject({\n  method: z.string().optional(),\n  id: z.union([z.string(), z.number(), z.null()]).optional(),\n  params: jsonValueSchema.optional(),\n  result: jsonValueSchema.optional(),\n  error: z.looseObject({ code: z.number(), message: z.string() }).optional(),\n});\n\nconst cancelParamsSchema = z.object({ requestId: z.string() });\n\nexport interface HostRequestContextIface {\n  id: string;\n  params: z.output<typeof jsonValueSchema> | undefined;\n  signal: AbortSignal;\n}\n\nexport interface HostPeerIface {\n  request: (method: string, params: z.input<typeof jsonValueSchema>) => Promise<unknown>;\n  notify: (method: string, params: z.input<typeof jsonValueSchema>) => void;\n  close: (code?: number, reason?: string) => void;\n  /** Resolves when the socket closes, for any reason. */\n  closed: Promise<{ code: number; reason: string }>;\n  isClosed: () => boolean;\n}\n\n// JSON-RPC error codes the host protocol answers with.\nexport enum HostRpcErrorCode {\n  MethodNotFound = -32601,\n  InvalidParams = -32602,\n  Internal = -32603,\n  Cancelled = -32800,\n}\n\n/**\n * JSON-RPC 2.0 for the host protocol. Ids it sends are strings starting with\n * `host:`, so the far side routes their responses (see `isHostFrame`).\n */\nexport const createHostPeer = (args: {\n  channel: FrameChannelIface;\n  onRequest?: (method: string, context: HostRequestContextIface) => Promise<unknown>;\n  onNotification?: (method: string, params: z.output<typeof jsonValueSchema> | undefined) => void;\n  newId?: () => string;\n}): HostPeerIface => {\n  let counter = 0;\n  const newId = args.newId ?? (() => `${LOCAL_HOST_REQUEST_ID_PREFIX}${++counter}`);\n  const pending = new Map<\n    string,\n    { resolve: (value: unknown) => void; reject: (error: Error) => void }\n  >();\n  const inbound = new Map<string, AbortController>();\n  let closedInfo: { code: number; reason: string } | null = null;\n  let resolveClosed: (info: { code: number; reason: string }) => void = () => undefined;\n  const closed = new Promise<{ code: number; reason: string }>((resolve) => {\n    resolveClosed = resolve;\n  });\n  const send = (message: Record<string, unknown>) => {\n    if (closedInfo == null) args.channel.send(JSON.stringify({ jsonrpc: '2.0', ...message }));\n  };\n\n  const answer = async (method: string, id: string, params: HostRequestContextIface['params']) => {\n    const controller = new AbortController();\n    inbound.set(id, controller);\n    try {\n      const handler = args.onRequest;\n      if (handler == null) {\n        send({ id, error: { code: HostRpcErrorCode.MethodNotFound, message: method } });\n        return;\n      }\n      const result = await handler(method, { id, params, signal: controller.signal });\n      send(\n        controller.signal.aborted\n          ? { id, error: { code: HostRpcErrorCode.Cancelled, message: 'request cancelled' } }\n          : { id, result: result ?? {} },\n      );\n    } catch (cause) {\n      send({\n        id,\n        error: {\n          code: HostRpcErrorCode.Internal,\n          message: cause instanceof Error ? cause.message : String(cause),\n        },\n      });\n    } finally {\n      inbound.delete(id);\n    }\n  };\n\n  args.channel.listen({\n    frame: (frame) => {\n      if (typeof frame !== 'string') return;\n      let raw: unknown;\n      try {\n        raw = JSON.parse(frame);\n      } catch {\n        return;\n      }\n      const message = hostMessageSchema.safeParse(raw);\n      if (!message.success) return;\n      const { method, id } = message.data;\n      if (method === CANCEL_REQUEST_METHOD) {\n        const cancel = cancelParamsSchema.safeParse(message.data.params);\n        if (cancel.success) inbound.get(cancel.data.requestId)?.abort();\n        return;\n      }\n      if (method != null) {\n        if (id == null) args.onNotification?.(method, message.data.params);\n        else void answer(method, String(id), message.data.params);\n        return;\n      }\n      if (typeof id !== 'string') return;\n      const waiter = pending.get(id);\n      if (waiter == null) return;\n      pending.delete(id);\n      if (message.data.error != null) waiter.reject(new Error(message.data.error.message));\n      else waiter.resolve(message.data.result ?? null);\n    },\n    close: (info) => {\n      if (closedInfo != null) return;\n      closedInfo = info;\n      for (const controller of inbound.values()) controller.abort();\n      for (const waiter of pending.values())\n        waiter.reject(new Error(`local host connection closed (${info.code})`));\n      pending.clear();\n      resolveClosed(info);\n    },\n  });\n\n  return {\n    request: (method, params) => {\n      if (closedInfo != null) return Promise.reject(new Error('local host connection is closed'));\n      const id = newId();\n      return new Promise<unknown>((resolve, reject) => {\n        pending.set(id, { resolve, reject });\n        send({ id, method, params });\n      });\n    },\n    notify: (method, params) => send({ method, params }),\n    close: (code, reason) => args.channel.close(code, reason),\n    closed,\n    isClosed: () => closedInfo != null,\n  };\n};\n"],
+  "mappings": "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",
+  "names": ["LocalHostMethod", "LocalHostOwnerKind", "HostRpcErrorCode"]
+}

package/dist/modules/agent-client/local-host.d.mts

@@ -0,0 +1,56 @@
+import { type Capability } from '@finalai/agent-protocol';
+import { type CodeSandboxEndpointIface } from '@finalai/agent-provider/code-host';
+import type { SandboxClientIface } from '@finalai/agent-provider/sandbox/client';
+import type { NetworkSandboxSessionIface } from '@finalai/agent-provider/sandbox/types';
+import type { FrameChannelIface } from '@finalai/agent-provider/sandbox/wire';
+import type { ResolvedAgentIface } from "./agent-input.mjs";
+import { type LocalHostOwnerIface } from "./local-host-protocol.mjs";
+export interface LocalComputeIface {
+    /** The sandbox this process serves `files` and `shell` from. */
+    sandbox: () => Promise<NetworkSandboxSessionIface>;
+    /** Connects `ctx.sandbox(capability)` in in-process code to a sandbox endpoint. */
+    openSandbox: (endpoint: CodeSandboxEndpointIface) => Promise<SandboxClientIface>;
+}
+/**
+ * Whether the socket keeps this Node process alive. The connection holds it
+ * while it starts and while the platform is using it (a code call, a sandbox
+ * operation, a running command), and lets an idle script exit.
+ */
+export interface LocalHostKeepAliveIface {
+    ref: () => void;
+    unref: () => void;
+}
+export interface LocalHostSocketIface extends FrameChannelIface {
+    /** Absent: the socket's lifetime is not this process's concern. */
+    keepAlive?: LocalHostKeepAliveIface;
+}
+export interface OpenLocalHostArgsIface {
+    /** Opens the socket at an API path (`/v1/projects/:id/local-hosts`), referenced. */
+    dial: (path: string, signal?: AbortSignal) => Promise<LocalHostSocketIface>;
+    projectId: string;
+    owner: LocalHostOwnerIface;
+    agent: ResolvedAgentIface;
+    /** Capabilities served from this process; may be empty. */
+    capabilities: Capability[];
+    compute: LocalComputeIface;
+    /** Abandons opening: the connection closes and whatever it started stops. */
+    signal?: AbortSignal;
+}
+export interface LocalHostIface {
+    hostId: string;
+    /** The session or conversation id the platform reserved or confirmed. */
+    ownerId: string;
+    /** What names this process's compute in `provide.compute`; null when it serves none. */
+    sandboxId: string | null;
+    closed: Promise<{
+        code: number;
+        reason: string;
+    }>;
+    close: () => void;
+    /**
+     * The session or conversation it serves exists: the socket stops keeping
+     * the process alive while nothing uses it.
+     */
+    established: () => void;
+}
+export declare const openLocalHost: (args: OpenLocalHostArgsIface) => Promise<LocalHostIface>;