@finalai/agent-provider 0.1.0

package/dist/modules/manifest.mjs

@@ -0,0 +1,266 @@
+import * as z from "zod";
+import { containsDynamicSlot, DynamicEvent, maybeDynamic } from "./dynamic.mjs";
+import { jsonObjectSchema, jsonSchemaSchema, jsonValueSchema } from "./json.mjs";
+import { packageRef, providerRefSchema } from "./provider-ref.mjs";
+const MANIFEST_VERSION = 2;
+var BaseCapability = /* @__PURE__ */ ((BaseCapability2) => {
+  BaseCapability2["Shell"] = "shell";
+  BaseCapability2["Files"] = "files";
+  BaseCapability2["Process"] = "process";
+  BaseCapability2["Ports"] = "ports";
+  BaseCapability2["Browser"] = "browser";
+  BaseCapability2["ComputerUse"] = "computerUse";
+  return BaseCapability2;
+})(BaseCapability || {});
+var ToolApproval = /* @__PURE__ */ ((ToolApproval2) => {
+  ToolApproval2["Allow"] = "allow";
+  ToolApproval2["Ask"] = "ask";
+  return ToolApproval2;
+})(ToolApproval || {});
+var SandboxAccess = /* @__PURE__ */ ((SandboxAccess2) => {
+  SandboxAccess2["Read"] = "read";
+  SandboxAccess2["Execute"] = "execute";
+  SandboxAccess2["Write"] = "write";
+  return SandboxAccess2;
+})(SandboxAccess || {});
+const SANDBOX_ACCESS_RANK = {
+  ["read" /* Read */]: 0,
+  ["execute" /* Execute */]: 1,
+  ["write" /* Write */]: 2
+};
+const sandboxAccessAtLeast = (access, floor) => SANDBOX_ACCESS_RANK[access] >= SANDBOX_ACCESS_RANK[floor];
+const narrowerSandboxAccess = (a, b) => SANDBOX_ACCESS_RANK[a] <= SANDBOX_ACCESS_RANK[b] ? a : b;
+var SandboxAttach = /* @__PURE__ */ ((SandboxAttach2) => {
+  SandboxAttach2["Lazy"] = "lazy";
+  SandboxAttach2["OnPrompt"] = "on-prompt";
+  return SandboxAttach2;
+})(SandboxAttach || {});
+var McpServerBindingKind = /* @__PURE__ */ ((McpServerBindingKind2) => {
+  McpServerBindingKind2["Worker"] = "worker";
+  McpServerBindingKind2["Http"] = "http";
+  return McpServerBindingKind2;
+})(McpServerBindingKind || {});
+var ScheduleTarget = /* @__PURE__ */ ((ScheduleTarget2) => {
+  ScheduleTarget2["OwnerDirect"] = "owner-direct";
+  ScheduleTarget2["BoundConversation"] = "bound-conversation";
+  return ScheduleTarget2;
+})(ScheduleTarget || {});
+var ScheduleDelivery = /* @__PURE__ */ ((ScheduleDelivery2) => {
+  ScheduleDelivery2["Always"] = "always";
+  ScheduleDelivery2["IfNeeded"] = "if_needed";
+  return ScheduleDelivery2;
+})(ScheduleDelivery || {});
+const identitySchema = z.object({
+  name: z.string().min(1).max(120),
+  description: z.string().max(2e3).nullable(),
+  avatarUrl: z.string().url().nullable()
+});
+var InputApprovalKind = /* @__PURE__ */ ((InputApprovalKind2) => {
+  InputApprovalKind2["Tool"] = "tool";
+  InputApprovalKind2["Connection"] = "connection";
+  return InputApprovalKind2;
+})(InputApprovalKind || {});
+const inputApprovalSchema = z.object({
+  kind: z.nativeEnum(InputApprovalKind),
+  export: z.string().min(1),
+  // Connection default when absent; otherwise tools.approval[policyKey].
+  policyKey: z.string().min(1).optional(),
+  dynamic: jsonObjectSchema.optional()
+});
+const toolDescriptorSchema = z.object({
+  name: z.string().min(1),
+  description: z.string(),
+  inputSchema: jsonSchemaSchema,
+  outputSchema: jsonSchemaSchema.optional(),
+  annotations: z.object({
+    title: z.string().optional(),
+    readOnlyHint: z.boolean().optional(),
+    destructiveHint: z.boolean().optional(),
+    idempotentHint: z.boolean().optional(),
+    openWorldHint: z.boolean().optional()
+  }).optional(),
+  // Bundle export implementing it ('tools/lookup_release_notes').
+  export: z.string().min(1).optional(),
+  // Boundary snapshot used to reconstruct dynamic tools after isolate eviction.
+  dynamic: jsonObjectSchema.optional(),
+  inputApproval: inputApprovalSchema.optional()
+});
+const mcpAuthSchema = z.union([
+  z.object({ secretKey: z.string().min(1), headerName: z.string().min(1).nullable() }),
+  // Resolved by the broker to a session-scoped grant (Final's own MCP server).
+  z.object({ kind: z.literal("final-session") })
+]);
+const toolApprovalsSchema = z.record(z.string(), z.nativeEnum(ToolApproval)).nullable();
+const workerMcpServerBindingSchema = z.object({
+  key: z.string().min(1),
+  kind: z.literal("worker" /* Worker */),
+  tools: z.array(toolDescriptorSchema),
+  approvals: toolApprovalsSchema
+});
+const httpMcpServerBindingSchema = z.object({
+  key: z.string().min(1),
+  kind: z.literal("http" /* Http */),
+  url: z.string().url(),
+  auth: mcpAuthSchema.nullable(),
+  headers: z.record(z.string(), z.string()).default({}),
+  // Null allows every tool the server lists, each with the default approval.
+  approvals: toolApprovalsSchema,
+  // Tools hidden even when `approvals` would expose them.
+  deny: z.array(z.string().min(1)).optional(),
+  // The authored resolver that produced this connection, for retained boundary values.
+  dynamicResolver: z.string().min(1).optional(),
+  inputApprovals: z.record(z.string(), inputApprovalSchema).optional()
+});
+const mcpServerBindingSchema = z.discriminatedUnion("kind", [
+  workerMcpServerBindingSchema,
+  httpMcpServerBindingSchema
+]);
+const sandboxBindingSchema = z.object({
+  provider: providerRefSchema,
+  // Provider-defined environment options (`computer`: a setup guide reference or
+  // inline guide plus start-time parameters). Validated by the provider.
+  environment: maybeDynamic(jsonValueSchema),
+  access: z.nativeEnum(SandboxAccess).default("write" /* Write */),
+  attach: z.nativeEnum(SandboxAttach).default("lazy" /* Lazy */)
+});
+const baseToolsSchema = z.object({
+  base: z.partialRecord(z.nativeEnum(BaseCapability), z.object({ target: z.string().min(1) })),
+  // Capabilities declared on the harness's own host with no sandbox target
+  // (`baseTools({ shell: harnessHost })`): only a harness that
+  // provides them natively (host-disableable, host-fixed) can serve them.
+  host: z.array(z.nativeEnum(BaseCapability)).optional()
+});
+const channelBindingSchema = z.object({
+  // Stable within the definition; publish maps it to a binding id.
+  key: z.string().min(1),
+  channel: providerRefSchema,
+  config: jsonObjectSchema.default({}),
+  source: z.string().optional()
+});
+const hookBindingSchema = z.object({
+  slug: z.string().min(1),
+  export: z.string().min(1),
+  events: z.array(z.string().min(1)).min(1)
+});
+const scheduleDefinitionSchema = z.object({
+  key: z.string().min(1),
+  cron: z.string().min(1),
+  timezone: z.string().min(1),
+  prompt: z.string().min(1),
+  target: z.nativeEnum(ScheduleTarget)
+});
+const bundleSchema = z.object({
+  // Absent on historical revisions: the host must inspect their resources.
+  hasPreparationFiles: z.boolean().optional(),
+  hash: z.string().min(1),
+  // Dynamic slot path → resolver export and events.
+  resolvers: z.record(
+    z.string(),
+    z.object({ export: z.string().min(1), events: z.array(z.nativeEnum(DynamicEvent)).min(1) })
+  )
+});
+const harnessBindingSchema = z.object({
+  harness: providerRefSchema,
+  // Validated against the harness's configSchema; may contain dynamic slots at
+  // any depth (an instruction fragment, the model).
+  config: maybeDynamic(jsonValueSchema)
+});
+const agentManifestSchema = z.object({
+  version: z.literal(MANIFEST_VERSION),
+  identity: identitySchema,
+  harness: harnessBindingSchema,
+  mcpServers: maybeDynamic(z.array(mcpServerBindingSchema)),
+  sandboxes: maybeDynamic(z.record(z.string(), sandboxBindingSchema)),
+  tools: baseToolsSchema,
+  toolPolicy: z.record(z.string(), z.nativeEnum(ToolApproval)),
+  // Organization secrets this agent may read, by name (`secrets.get`,
+  // MCP `secretKey`, `apiKey({ secret })`). Nothing else is readable;
+  // binding organization secrets requires an organization admin at publish.
+  secrets: z.array(z.string().min(1)).default([]),
+  channels: z.array(channelBindingSchema),
+  channelSources: z.record(z.string(), z.object({ path: z.string(), source: z.string(), disabled: z.boolean() })).optional(),
+  hooks: z.array(hookBindingSchema),
+  schedules: z.array(scheduleDefinitionSchema),
+  bundle: bundleSchema.nullable()
+});
+const resolvedAgentManifestSchema = agentManifestSchema.extend({
+  harness: z.object({ harness: providerRefSchema, config: jsonValueSchema }),
+  mcpServers: z.array(mcpServerBindingSchema),
+  sandboxes: z.record(z.string(), sandboxBindingSchema.extend({ environment: jsonValueSchema }))
+}).superRefine((manifest, ctx) => {
+  if (containsDynamicSlot(manifest)) {
+    ctx.addIssue({
+      code: "custom",
+      message: "a resolved manifest must not contain dynamic slots"
+    });
+  }
+});
+var InstructionRole = /* @__PURE__ */ ((InstructionRole2) => {
+  InstructionRole2["System"] = "system";
+  InstructionRole2["User"] = "user";
+  return InstructionRole2;
+})(InstructionRole || {});
+const instructionFragmentSchema = z.object({
+  role: z.nativeEnum(InstructionRole),
+  content: z.string(),
+  // Source file, for the compatibility report and Build.
+  source: z.string().optional()
+});
+const skillFileSchema = z.object({ path: z.string().min(1), content: z.string() });
+const skillBundleSchema = z.object({
+  key: z.string().min(1),
+  description: z.string().optional(),
+  files: z.array(skillFileSchema)
+});
+const emptyManifest = (name) => ({
+  version: MANIFEST_VERSION,
+  identity: { name, description: null, avatarUrl: null },
+  harness: {
+    harness: packageRef("@finalai/final-agent-provider/harnesses/serverless-final"),
+    config: {}
+  },
+  mcpServers: [],
+  sandboxes: {},
+  tools: { base: {} },
+  toolPolicy: {},
+  secrets: [],
+  channels: [],
+  hooks: [],
+  schedules: [],
+  bundle: null
+});
+export {
+  BaseCapability,
+  InputApprovalKind,
+  InstructionRole,
+  MANIFEST_VERSION,
+  McpServerBindingKind,
+  SandboxAccess,
+  SandboxAttach,
+  ScheduleDelivery,
+  ScheduleTarget,
+  ToolApproval,
+  agentManifestSchema,
+  baseToolsSchema,
+  bundleSchema,
+  channelBindingSchema,
+  emptyManifest,
+  harnessBindingSchema,
+  hookBindingSchema,
+  httpMcpServerBindingSchema,
+  identitySchema,
+  inputApprovalSchema,
+  instructionFragmentSchema,
+  mcpAuthSchema,
+  mcpServerBindingSchema,
+  narrowerSandboxAccess,
+  resolvedAgentManifestSchema,
+  sandboxAccessAtLeast,
+  sandboxBindingSchema,
+  scheduleDefinitionSchema,
+  skillBundleSchema,
+  skillFileSchema,
+  toolDescriptorSchema,
+  workerMcpServerBindingSchema
+};
+//# sourceMappingURL=manifest.mjs.map

package/dist/modules/manifest.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/manifest.ts"],
+  "sourcesContent": ["import * as z from 'zod';\nimport { containsDynamicSlot, DynamicEvent, maybeDynamic } from \"./dynamic.mjs\";\nimport { jsonObjectSchema, jsonSchemaSchema, jsonValueSchema } from \"./json.mjs\";\nimport { packageRef, providerRefSchema } from \"./provider-ref.mjs\";\n\n// The Agent Manifest. It lives in the provider contract\n// package because it is what harnesses, sandboxes and channels receive;\n// @finalai/agent-definition compiles directories into it and re-exports it.\n//\n// A harness owns its loop, native tools, prompt assembly, models, permission\n// modes, memory and compaction: all of that is `harness.config`, typed by the\n// harness's own configSchema. What ACP standardizes (MCP servers, prompts,\n// permissions, cancellation) is session input, identical for every harness.\n\nexport const MANIFEST_VERSION = 2;\n\n// Base tool capability classes, one to one with sandbox handle capabilities.\nexport enum BaseCapability {\n  Shell = 'shell',\n  Files = 'files',\n  Process = 'process',\n  Ports = 'ports',\n  Browser = 'browser',\n  ComputerUse = 'computerUse',\n}\n\nexport enum ToolApproval {\n  Allow = 'allow',\n  Ask = 'ask',\n}\n\n// What a session may do on a sandbox target: read files; also run\n// processes (execute, without file writes); or everything (write).\nexport enum SandboxAccess {\n  Read = 'read',\n  Execute = 'execute',\n  Write = 'write',\n}\n\nconst SANDBOX_ACCESS_RANK = {\n  [SandboxAccess.Read]: 0,\n  [SandboxAccess.Execute]: 1,\n  [SandboxAccess.Write]: 2,\n} satisfies Record<SandboxAccess, number>;\n\n// Each access includes the ones before it: read < execute < write.\nexport const sandboxAccessAtLeast = (access: SandboxAccess, floor: SandboxAccess): boolean =>\n  SANDBOX_ACCESS_RANK[access] >= SANDBOX_ACCESS_RANK[floor];\n\nexport const narrowerSandboxAccess = (a: SandboxAccess, b: SandboxAccess): SandboxAccess =>\n  SANDBOX_ACCESS_RANK[a] <= SANDBOX_ACCESS_RANK[b] ? a : b;\n\nexport enum SandboxAttach {\n  Lazy = 'lazy',\n  OnPrompt = 'on-prompt',\n}\n\nexport enum McpServerBindingKind {\n  // Authored tools, served from the agent's Worker isolate behind the MCP host.\n  Worker = 'worker',\n  Http = 'http',\n}\n\nexport enum ScheduleTarget {\n  OwnerDirect = 'owner-direct',\n  BoundConversation = 'bound-conversation',\n}\n\n// Whether a schedule's firing must get a visible reply. Values match the schedules API.\nexport enum ScheduleDelivery {\n  Always = 'always',\n  // The agent replies only when there is something to say; an empty turn posts nothing.\n  IfNeeded = 'if_needed',\n}\n\nexport const identitySchema = z.object({\n  name: z.string().min(1).max(120),\n  description: z.string().max(2000).nullable(),\n  avatarUrl: z.string().url().nullable(),\n});\n\nexport enum InputApprovalKind {\n  Tool = 'tool',\n  Connection = 'connection',\n}\n\nexport const inputApprovalSchema = z.object({\n  kind: z.nativeEnum(InputApprovalKind),\n  export: z.string().min(1),\n  // Connection default when absent; otherwise tools.approval[policyKey].\n  policyKey: z.string().min(1).optional(),\n  dynamic: jsonObjectSchema.optional(),\n});\nexport type InputApprovalIface = z.infer<typeof inputApprovalSchema>;\n\n// Tool descriptors are stored statically so `tools/list` never needs the isolate.\nexport const toolDescriptorSchema = z.object({\n  name: z.string().min(1),\n  description: z.string(),\n  inputSchema: jsonSchemaSchema,\n  outputSchema: jsonSchemaSchema.optional(),\n  annotations: z\n    .object({\n      title: z.string().optional(),\n      readOnlyHint: z.boolean().optional(),\n      destructiveHint: z.boolean().optional(),\n      idempotentHint: z.boolean().optional(),\n      openWorldHint: z.boolean().optional(),\n    })\n    .optional(),\n  // Bundle export implementing it ('tools/lookup_release_notes').\n  export: z.string().min(1).optional(),\n  // Boundary snapshot used to reconstruct dynamic tools after isolate eviction.\n  dynamic: jsonObjectSchema.optional(),\n  inputApproval: inputApprovalSchema.optional(),\n});\n\nexport const mcpAuthSchema = z.union([\n  z.object({ secretKey: z.string().min(1), headerName: z.string().min(1).nullable() }),\n  // Resolved by the broker to a session-scoped grant (Final's own MCP server).\n  z.object({ kind: z.literal('final-session') }),\n]);\n\nconst toolApprovalsSchema = z.record(z.string(), z.nativeEnum(ToolApproval)).nullable();\n\nexport const workerMcpServerBindingSchema = z.object({\n  key: z.string().min(1),\n  kind: z.literal(McpServerBindingKind.Worker),\n  tools: z.array(toolDescriptorSchema),\n  approvals: toolApprovalsSchema,\n});\n\nexport const httpMcpServerBindingSchema = z.object({\n  key: z.string().min(1),\n  kind: z.literal(McpServerBindingKind.Http),\n  url: z.string().url(),\n  auth: mcpAuthSchema.nullable(),\n  headers: z.record(z.string(), z.string()).default({}),\n  // Null allows every tool the server lists, each with the default approval.\n  approvals: toolApprovalsSchema,\n  // Tools hidden even when `approvals` would expose them.\n  deny: z.array(z.string().min(1)).optional(),\n  // The authored resolver that produced this connection, for retained boundary values.\n  dynamicResolver: z.string().min(1).optional(),\n  inputApprovals: z.record(z.string(), inputApprovalSchema).optional(),\n});\n\nexport const mcpServerBindingSchema = z.discriminatedUnion('kind', [\n  workerMcpServerBindingSchema,\n  httpMcpServerBindingSchema,\n]);\n\nexport const sandboxBindingSchema = z.object({\n  provider: providerRefSchema,\n  // Provider-defined environment options (`computer`: a setup guide reference or\n  // inline guide plus start-time parameters). Validated by the provider.\n  environment: maybeDynamic(jsonValueSchema),\n  access: z.nativeEnum(SandboxAccess).default(SandboxAccess.Write),\n  attach: z.nativeEnum(SandboxAttach).default(SandboxAttach.Lazy),\n});\n\nexport const baseToolsSchema = z.object({\n  base: z.partialRecord(z.nativeEnum(BaseCapability), z.object({ target: z.string().min(1) })),\n  // Capabilities declared on the harness's own host with no sandbox target\n  // (`baseTools({ shell: harnessHost })`): only a harness that\n  // provides them natively (host-disableable, host-fixed) can serve them.\n  host: z.array(z.nativeEnum(BaseCapability)).optional(),\n});\n\nexport const channelBindingSchema = z.object({\n  // Stable within the definition; publish maps it to a binding id.\n  key: z.string().min(1),\n  channel: providerRefSchema,\n  config: jsonObjectSchema.default({}),\n  source: z.string().optional(),\n});\n\nexport const hookBindingSchema = z.object({\n  slug: z.string().min(1),\n  export: z.string().min(1),\n  events: z.array(z.string().min(1)).min(1),\n});\n\nexport const scheduleDefinitionSchema = z.object({\n  key: z.string().min(1),\n  cron: z.string().min(1),\n  timezone: z.string().min(1),\n  prompt: z.string().min(1),\n  target: z.nativeEnum(ScheduleTarget),\n});\n\nexport const bundleSchema = z.object({\n  // Absent on historical revisions: the host must inspect their resources.\n  hasPreparationFiles: z.boolean().optional(),\n  hash: z.string().min(1),\n  // Dynamic slot path \u2192 resolver export and events.\n  resolvers: z.record(\n    z.string(),\n    z.object({ export: z.string().min(1), events: z.array(z.nativeEnum(DynamicEvent)).min(1) }),\n  ),\n});\n\nexport const harnessBindingSchema = z.object({\n  harness: providerRefSchema,\n  // Validated against the harness's configSchema; may contain dynamic slots at\n  // any depth (an instruction fragment, the model).\n  config: maybeDynamic(jsonValueSchema),\n});\n\nexport const agentManifestSchema = z.object({\n  version: z.literal(MANIFEST_VERSION),\n  identity: identitySchema,\n  harness: harnessBindingSchema,\n  mcpServers: maybeDynamic(z.array(mcpServerBindingSchema)),\n  sandboxes: maybeDynamic(z.record(z.string(), sandboxBindingSchema)),\n  tools: baseToolsSchema,\n  toolPolicy: z.record(z.string(), z.nativeEnum(ToolApproval)),\n  // Organization secrets this agent may read, by name (`secrets.get`,\n  // MCP `secretKey`, `apiKey({ secret })`). Nothing else is readable;\n  // binding organization secrets requires an organization admin at publish.\n  secrets: z.array(z.string().min(1)).default([]),\n  channels: z.array(channelBindingSchema),\n  channelSources: z\n    .record(z.string(), z.object({ path: z.string(), source: z.string(), disabled: z.boolean() }))\n    .optional(),\n  hooks: z.array(hookBindingSchema),\n  schedules: z.array(scheduleDefinitionSchema),\n  bundle: bundleSchema.nullable(),\n});\n\n// What one session actually got: every dynamic slot replaced by its resolved\n// value (stored in agent.session_manifests).\nexport const resolvedAgentManifestSchema = agentManifestSchema\n  .extend({\n    harness: z.object({ harness: providerRefSchema, config: jsonValueSchema }),\n    mcpServers: z.array(mcpServerBindingSchema),\n    sandboxes: z.record(z.string(), sandboxBindingSchema.extend({ environment: jsonValueSchema })),\n  })\n  .superRefine((manifest, ctx) => {\n    if (containsDynamicSlot(manifest)) {\n      ctx.addIssue({\n        code: 'custom',\n        message: 'a resolved manifest must not contain dynamic slots',\n      });\n    }\n  });\n\nexport type IdentityIface = z.infer<typeof identitySchema>;\nexport type ToolDescriptorIface = z.infer<typeof toolDescriptorSchema>;\nexport type McpAuth = z.infer<typeof mcpAuthSchema>;\nexport type WorkerMcpServerBindingIface = z.infer<typeof workerMcpServerBindingSchema>;\nexport type HttpMcpServerBindingIface = z.infer<typeof httpMcpServerBindingSchema>;\nexport type McpServerBinding = z.infer<typeof mcpServerBindingSchema>;\nexport type SandboxBindingIface = z.infer<typeof sandboxBindingSchema>;\nexport type BaseToolsIface = z.infer<typeof baseToolsSchema>;\nexport type ChannelBindingIface = z.infer<typeof channelBindingSchema>;\nexport type HookBindingIface = z.infer<typeof hookBindingSchema>;\nexport type ScheduleDefinitionIface = z.infer<typeof scheduleDefinitionSchema>;\nexport type BundleIface = z.infer<typeof bundleSchema>;\nexport type HarnessBindingIface = z.infer<typeof harnessBindingSchema>;\nexport type AgentManifestIface = z.infer<typeof agentManifestSchema>;\nexport type ResolvedAgentManifestIface = z.infer<typeof resolvedAgentManifestSchema>;\nexport type ResolvedSandboxBindingIface = ResolvedAgentManifestIface['sandboxes'][string];\n\n// The fields of a harness config the platform itself reads through the shared\n// schema fragments; everything else is opaque to the platform.\nexport enum InstructionRole {\n  System = 'system',\n  User = 'user',\n}\n\nexport const instructionFragmentSchema = z.object({\n  role: z.nativeEnum(InstructionRole),\n  content: z.string(),\n  // Source file, for the compatibility report and Build.\n  source: z.string().optional(),\n});\n\nexport const skillFileSchema = z.object({ path: z.string().min(1), content: z.string() });\nexport const skillBundleSchema = z.object({\n  key: z.string().min(1),\n  description: z.string().optional(),\n  files: z.array(skillFileSchema),\n});\n\nexport type InstructionFragmentIface = z.infer<typeof instructionFragmentSchema>;\nexport type SkillBundleIface = z.infer<typeof skillBundleSchema>;\n\nexport const emptyManifest = (name: string): AgentManifestIface => ({\n  version: MANIFEST_VERSION,\n  identity: { name, description: null, avatarUrl: null },\n  harness: {\n    harness: packageRef('@finalai/final-agent-provider/harnesses/serverless-final'),\n    config: {},\n  },\n  mcpServers: [],\n  sandboxes: {},\n  tools: { base: {} },\n  toolPolicy: {},\n  secrets: [],\n  channels: [],\n  hooks: [],\n  schedules: [],\n  bundle: null,\n});\n"],
+  "mappings": "AAAA,YAAY,OAAO;AACnB,SAAS,qBAAqB,cAAc,oBAAoB;AAChE,SAAS,kBAAkB,kBAAkB,uBAAuB;AACpE,SAAS,YAAY,yBAAyB;AAWvC,MAAM,mBAAmB;AAGzB,IAAK,iBAAL,kBAAKA,oBAAL;AACL,EAAAA,gBAAA,WAAQ;AACR,EAAAA,gBAAA,WAAQ;AACR,EAAAA,gBAAA,aAAU;AACV,EAAAA,gBAAA,WAAQ;AACR,EAAAA,gBAAA,aAAU;AACV,EAAAA,gBAAA,iBAAc;AANJ,SAAAA;AAAA,GAAA;AASL,IAAK,eAAL,kBAAKC,kBAAL;AACL,EAAAA,cAAA,WAAQ;AACR,EAAAA,cAAA,SAAM;AAFI,SAAAA;AAAA,GAAA;AAOL,IAAK,gBAAL,kBAAKC,mBAAL;AACL,EAAAA,eAAA,UAAO;AACP,EAAAA,eAAA,aAAU;AACV,EAAAA,eAAA,WAAQ;AAHE,SAAAA;AAAA,GAAA;AAMZ,MAAM,sBAAsB;AAAA,EAC1B,CAAC,iBAAkB,GAAG;AAAA,EACtB,CAAC,uBAAqB,GAAG;AAAA,EACzB,CAAC,mBAAmB,GAAG;AACzB;AAGO,MAAM,uBAAuB,CAAC,QAAuB,UAC1D,oBAAoB,MAAM,KAAK,oBAAoB,KAAK;AAEnD,MAAM,wBAAwB,CAAC,GAAkB,MACtD,oBAAoB,CAAC,KAAK,oBAAoB,CAAC,IAAI,IAAI;AAElD,IAAK,gBAAL,kBAAKC,mBAAL;AACL,EAAAA,eAAA,UAAO;AACP,EAAAA,eAAA,cAAW;AAFD,SAAAA;AAAA,GAAA;AAKL,IAAK,uBAAL,kBAAKC,0BAAL;AAEL,EAAAA,sBAAA,YAAS;AACT,EAAAA,sBAAA,UAAO;AAHG,SAAAA;AAAA,GAAA;AAML,IAAK,iBAAL,kBAAKC,oBAAL;AACL,EAAAA,gBAAA,iBAAc;AACd,EAAAA,gBAAA,uBAAoB;AAFV,SAAAA;AAAA,GAAA;AAML,IAAK,mBAAL,kBAAKC,sBAAL;AACL,EAAAA,kBAAA,YAAS;AAET,EAAAA,kBAAA,cAAW;AAHD,SAAAA;AAAA,GAAA;AAML,MAAM,iBAAiB,EAAE,OAAO;AAAA,EACrC,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,IAAI,GAAG;AAAA,EAC/B,aAAa,EAAE,OAAO,EAAE,IAAI,GAAI,EAAE,SAAS;AAAA,EAC3C,WAAW,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS;AACvC,CAAC;AAEM,IAAK,oBAAL,kBAAKC,uBAAL;AACL,EAAAA,mBAAA,UAAO;AACP,EAAAA,mBAAA,gBAAa;AAFH,SAAAA;AAAA,GAAA;AAKL,MAAM,sBAAsB,EAAE,OAAO;AAAA,EAC1C,MAAM,EAAE,WAAW,iBAAiB;AAAA,EACpC,QAAQ,EAAE,OAAO,EAAE,IAAI,CAAC;AAAA;AAAA,EAExB,WAAW,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,SAAS;AAAA,EACtC,SAAS,iBAAiB,SAAS;AACrC,CAAC;AAIM,MAAM,uBAAuB,EAAE,OAAO;AAAA,EAC3C,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC;AAAA,EACtB,aAAa,EAAE,OAAO;AAAA,EACtB,aAAa;AAAA,EACb,cAAc,iBAAiB,SAAS;AAAA,EACxC,aAAa,EACV,OAAO;AAAA,IACN,OAAO,EAAE,OAAO,EAAE,SAAS;AAAA,IAC3B,cAAc,EAAE,QAAQ,EAAE,SAAS;AAAA,IACnC,iBAAiB,EAAE,QAAQ,EAAE,SAAS;AAAA,IACtC,gBAAgB,EAAE,QAAQ,EAAE,SAAS;AAAA,IACrC,eAAe,EAAE,QAAQ,EAAE,SAAS;AAAA,EACtC,CAAC,EACA,SAAS;AAAA;AAAA,EAEZ,QAAQ,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,SAAS;AAAA;AAAA,EAEnC,SAAS,iBAAiB,SAAS;AAAA,EACnC,eAAe,oBAAoB,SAAS;AAC9C,CAAC;AAEM,MAAM,gBAAgB,EAAE,MAAM;AAAA,EACnC,EAAE,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,IAAI,CAAC,GAAG,YAAY,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,SAAS,EAAE,CAAC;AAAA;AAAA,EAEnF,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,eAAe,EAAE,CAAC;AAC/C,CAAC;AAED,MAAM,sBAAsB,EAAE,OAAO,EAAE,OAAO,GAAG,EAAE,WAAW,YAAY,CAAC,EAAE,SAAS;AAE/E,MAAM,+BAA+B,EAAE,OAAO;AAAA,EACnD,KAAK,EAAE,OAAO,EAAE,IAAI,CAAC;AAAA,EACrB,MAAM,EAAE,QAAQ,qBAA2B;AAAA,EAC3C,OAAO,EAAE,MAAM,oBAAoB;AAAA,EACnC,WAAW;AACb,CAAC;AAEM,MAAM,6BAA6B,EAAE,OAAO;AAAA,EACjD,KAAK,EAAE,OAAO,EAAE,IAAI,CAAC;AAAA,EACrB,MAAM,EAAE,QAAQ,iBAAyB;AAAA,EACzC,KAAK,EAAE,OAAO,EAAE,IAAI;AAAA,EACpB,MAAM,cAAc,SAAS;AAAA,EAC7B,SAAS,EAAE,OAAO,EAAE,OAAO,GAAG,EAAE,OAAO,CAAC,EAAE,QAAQ,CAAC,CAAC;AAAA;AAAA,EAEpD,WAAW;AAAA;AAAA,EAEX,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC,EAAE,SAAS;AAAA;AAAA,EAE1C,iBAAiB,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,SAAS;AAAA,EAC5C,gBAAgB,EAAE,OAAO,EAAE,OAAO,GAAG,mBAAmB,EAAE,SAAS;AACrE,CAAC;AAEM,MAAM,yBAAyB,EAAE,mBAAmB,QAAQ;AAAA,EACjE;AAAA,EACA;AACF,CAAC;AAEM,MAAM,uBAAuB,EAAE,OAAO;AAAA,EAC3C,UAAU;AAAA;AAAA;AAAA,EAGV,aAAa,aAAa,eAAe;AAAA,EACzC,QAAQ,EAAE,WAAW,aAAa,EAAE,QAAQ,mBAAmB;AAAA,EAC/D,QAAQ,EAAE,WAAW,aAAa,EAAE,QAAQ,iBAAkB;AAChE,CAAC;AAEM,MAAM,kBAAkB,EAAE,OAAO;AAAA,EACtC,MAAM,EAAE,cAAc,EAAE,WAAW,cAAc,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,CAAC,CAAC;AAAA;AAAA;AAAA;AAAA,EAI3F,MAAM,EAAE,MAAM,EAAE,WAAW,cAAc,CAAC,EAAE,SAAS;AACvD,CAAC;AAEM,MAAM,uBAAuB,EAAE,OAAO;AAAA;AAAA,EAE3C,KAAK,EAAE,OAAO,EAAE,IAAI,CAAC;AAAA,EACrB,SAAS;AAAA,EACT,QAAQ,iBAAiB,QAAQ,CAAC,CAAC;AAAA,EACnC,QAAQ,EAAE,OAAO,EAAE,SAAS;AAC9B,CAAC;AAEM,MAAM,oBAAoB,EAAE,OAAO;AAAA,EACxC,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC;AAAA,EACtB,QAAQ,EAAE,OAAO,EAAE,IAAI,CAAC;AAAA,EACxB,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC;AAC1C,CAAC;AAEM,MAAM,2BAA2B,EAAE,OAAO;AAAA,EAC/C,KAAK,EAAE,OAAO,EAAE,IAAI,CAAC;AAAA,EACrB,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC;AAAA,EACtB,UAAU,EAAE,OAAO,EAAE,IAAI,CAAC;AAAA,EAC1B,QAAQ,EAAE,OAAO,EAAE,IAAI,CAAC;AAAA,EACxB,QAAQ,EAAE,WAAW,cAAc;AACrC,CAAC;AAEM,MAAM,eAAe,EAAE,OAAO;AAAA;AAAA,EAEnC,qBAAqB,EAAE,QAAQ,EAAE,SAAS;AAAA,EAC1C,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC;AAAA;AAAA,EAEtB,WAAW,EAAE;AAAA,IACX,EAAE,OAAO;AAAA,IACT,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,IAAI,CAAC,GAAG,QAAQ,EAAE,MAAM,EAAE,WAAW,YAAY,CAAC,EAAE,IAAI,CAAC,EAAE,CAAC;AAAA,EAC5F;AACF,CAAC;AAEM,MAAM,uBAAuB,EAAE,OAAO;AAAA,EAC3C,SAAS;AAAA;AAAA;AAAA,EAGT,QAAQ,aAAa,eAAe;AACtC,CAAC;AAEM,MAAM,sBAAsB,EAAE,OAAO;AAAA,EAC1C,SAAS,EAAE,QAAQ,gBAAgB;AAAA,EACnC,UAAU;AAAA,EACV,SAAS;AAAA,EACT,YAAY,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAAA,EACxD,WAAW,aAAa,EAAE,OAAO,EAAE,OAAO,GAAG,oBAAoB,CAAC;AAAA,EAClE,OAAO;AAAA,EACP,YAAY,EAAE,OAAO,EAAE,OAAO,GAAG,EAAE,WAAW,YAAY,CAAC;AAAA;AAAA;AAAA;AAAA,EAI3D,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC;AAAA,EAC9C,UAAU,EAAE,MAAM,oBAAoB;AAAA,EACtC,gBAAgB,EACb,OAAO,EAAE,OAAO,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,GAAG,QAAQ,EAAE,OAAO,GAAG,UAAU,EAAE,QAAQ,EAAE,CAAC,CAAC,EAC5F,SAAS;AAAA,EACZ,OAAO,EAAE,MAAM,iBAAiB;AAAA,EAChC,WAAW,EAAE,MAAM,wBAAwB;AAAA,EAC3C,QAAQ,aAAa,SAAS;AAChC,CAAC;AAIM,MAAM,8BAA8B,oBACxC,OAAO;AAAA,EACN,SAAS,EAAE,OAAO,EAAE,SAAS,mBAAmB,QAAQ,gBAAgB,CAAC;AAAA,EACzE,YAAY,EAAE,MAAM,sBAAsB;AAAA,EAC1C,WAAW,EAAE,OAAO,EAAE,OAAO,GAAG,qBAAqB,OAAO,EAAE,aAAa,gBAAgB,CAAC,CAAC;AAC/F,CAAC,EACA,YAAY,CAAC,UAAU,QAAQ;AAC9B,MAAI,oBAAoB,QAAQ,GAAG;AACjC,QAAI,SAAS;AAAA,MACX,MAAM;AAAA,MACN,SAAS;AAAA,IACX,CAAC;AAAA,EACH;AACF,CAAC;AAqBI,IAAK,kBAAL,kBAAKC,qBAAL;AACL,EAAAA,iBAAA,YAAS;AACT,EAAAA,iBAAA,UAAO;AAFG,SAAAA;AAAA,GAAA;AAKL,MAAM,4BAA4B,EAAE,OAAO;AAAA,EAChD,MAAM,EAAE,WAAW,eAAe;AAAA,EAClC,SAAS,EAAE,OAAO;AAAA;AAAA,EAElB,QAAQ,EAAE,OAAO,EAAE,SAAS;AAC9B,CAAC;AAEM,MAAM,kBAAkB,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC,GAAG,SAAS,EAAE,OAAO,EAAE,CAAC;AACjF,MAAM,oBAAoB,EAAE,OAAO;AAAA,EACxC,KAAK,EAAE,OAAO,EAAE,IAAI,CAAC;AAAA,EACrB,aAAa,EAAE,OAAO,EAAE,SAAS;AAAA,EACjC,OAAO,EAAE,MAAM,eAAe;AAChC,CAAC;AAKM,MAAM,gBAAgB,CAAC,UAAsC;AAAA,EAClE,SAAS;AAAA,EACT,UAAU,EAAE,MAAM,aAAa,MAAM,WAAW,KAAK;AAAA,EACrD,SAAS;AAAA,IACP,SAAS,WAAW,0DAA0D;AAAA,IAC9E,QAAQ,CAAC;AAAA,EACX;AAAA,EACA,YAAY,CAAC;AAAA,EACb,WAAW,CAAC;AAAA,EACZ,OAAO,EAAE,MAAM,CAAC,EAAE;AAAA,EAClB,YAAY,CAAC;AAAA,EACb,SAAS,CAAC;AAAA,EACV,UAAU,CAAC;AAAA,EACX,OAAO,CAAC;AAAA,EACR,WAAW,CAAC;AAAA,EACZ,QAAQ;AACV;",
+  "names": ["BaseCapability", "ToolApproval", "SandboxAccess", "SandboxAttach", "McpServerBindingKind", "ScheduleTarget", "ScheduleDelivery", "InputApprovalKind", "InstructionRole"]
+}

package/dist/modules/mcp-content.d.mts

@@ -0,0 +1,21 @@
+import { type JsonValue } from '@finalai/acp-session';
+export declare const MAX_MCP_CONTENT_BYTES: number;
+export interface McpAttachmentIface {
+    bytes: Uint8Array;
+    mimeType: string;
+}
+export type ReadMcpAttachment = (uri: string, signal?: AbortSignal) => Promise<McpAttachmentIface | null>;
+export declare const restoreMcpContent: (args: {
+    result: unknown;
+    read: ReadMcpAttachment;
+    signal?: AbortSignal;
+}) => Promise<JsonValue>;
+export declare const readMcpAttachment: (args: {
+    fetch: typeof fetch;
+    endpoint: {
+        url: string;
+        token: string | null;
+    };
+    uri: string;
+    signal?: AbortSignal;
+}) => Promise<McpAttachmentIface | null>;

package/dist/modules/mcp-content.mjs

@@ -0,0 +1,86 @@
+import { jsonObjectSchema, jsonValueSchema } from "@finalai/acp-session";
+import * as z from "zod";
+const MAX_MCP_CONTENT_BYTES = 16 * 1024 * 1024;
+const restoreMcpContent = async (args) => {
+  const original = jsonValueSchema.parse(args.result);
+  const parsed = jsonObjectSchema.safeParse(original);
+  if (!parsed.success) return original;
+  const result = parsed.data;
+  if (!Array.isArray(result.content)) return result;
+  let restoredBytes = 0;
+  const content = [];
+  for (const block of result.content) {
+    const link = z.object({ type: z.literal("resource_link"), uri: z.string(), mimeType: z.string() }).safeParse(block);
+    if (!link.success || !link.data.uri.startsWith("final-attachment:")) {
+      content.push(block);
+      continue;
+    }
+    const image = link.data.mimeType.startsWith("image/");
+    const text = link.data.mimeType.startsWith("text/");
+    if (!image && !text) {
+      content.push(block);
+      continue;
+    }
+    args.signal?.throwIfAborted();
+    const stored = await args.read(link.data.uri, args.signal);
+    if (stored == null) throw new Error("MCP attachment is unavailable");
+    restoredBytes += stored.bytes.byteLength;
+    if (restoredBytes > MAX_MCP_CONTENT_BYTES) throw new Error("MCP content exceeds native limit");
+    if (stored.mimeType !== link.data.mimeType) throw new Error("MCP attachment type mismatch");
+    if (image) {
+      let binary = "";
+      for (let offset = 0; offset < stored.bytes.length; offset += 8192)
+        binary += String.fromCharCode(...stored.bytes.subarray(offset, offset + 8192));
+      content.push({ type: "image", data: btoa(binary), mimeType: stored.mimeType });
+    } else
+      content.push({
+        type: "text",
+        text: new TextDecoder("utf-8", { fatal: true }).decode(stored.bytes)
+      });
+  }
+  return { ...result, content };
+};
+const readMcpAttachment = async (args) => {
+  const response = await args.fetch(args.endpoint.url, {
+    method: "POST",
+    redirect: "manual",
+    headers: args.endpoint.token == null ? { "content-type": "application/json" } : { authorization: `Bearer ${args.endpoint.token}`, "content-type": "application/json" },
+    body: JSON.stringify({ uri: args.uri }),
+    signal: args.signal
+  });
+  if (!response.ok) {
+    await response.body?.cancel();
+    return null;
+  }
+  const reader = response.body?.getReader();
+  if (reader == null) return null;
+  const chunks = [];
+  let size = 0;
+  try {
+    for (; ; ) {
+      const next = await reader.read();
+      if (next.done) break;
+      size += next.value.byteLength;
+      if (size > MAX_MCP_CONTENT_BYTES) {
+        await reader.cancel();
+        throw new Error("MCP attachment exceeds limit");
+      }
+      chunks.push(next.value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const bytes = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return { bytes, mimeType: response.headers.get("content-type") ?? "application/octet-stream" };
+};
+export {
+  MAX_MCP_CONTENT_BYTES,
+  readMcpAttachment,
+  restoreMcpContent
+};
+//# sourceMappingURL=mcp-content.mjs.map

package/dist/modules/mcp-content.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/mcp-content.ts"],
+  "sourcesContent": ["import { jsonObjectSchema, jsonValueSchema, type JsonValue } from '@finalai/acp-session';\nimport * as z from 'zod';\n\nexport const MAX_MCP_CONTENT_BYTES = 16 * 1024 * 1024;\nexport interface McpAttachmentIface {\n  bytes: Uint8Array;\n  mimeType: string;\n}\nexport type ReadMcpAttachment = (\n  uri: string,\n  signal?: AbortSignal,\n) => Promise<McpAttachmentIface | null>;\n\n// Only session-owned attachment URIs are dereferenced. Arbitrary tool URLs stay links.\nexport const restoreMcpContent = async (args: {\n  result: unknown;\n  read: ReadMcpAttachment;\n  signal?: AbortSignal;\n}): Promise<JsonValue> => {\n  const original = jsonValueSchema.parse(args.result);\n  const parsed = jsonObjectSchema.safeParse(original);\n  if (!parsed.success) return original;\n  const result = parsed.data;\n  if (!Array.isArray(result.content)) return result;\n  let restoredBytes = 0;\n  const content: JsonValue[] = [];\n  for (const block of result.content) {\n    const link = z\n      .object({ type: z.literal('resource_link'), uri: z.string(), mimeType: z.string() })\n      .safeParse(block);\n    if (!link.success || !link.data.uri.startsWith('final-attachment:')) {\n      content.push(block);\n      continue;\n    }\n    const image = link.data.mimeType.startsWith('image/');\n    const text = link.data.mimeType.startsWith('text/');\n    if (!image && !text) {\n      content.push(block);\n      continue;\n    }\n    args.signal?.throwIfAborted();\n    const stored = await args.read(link.data.uri, args.signal);\n    if (stored == null) throw new Error('MCP attachment is unavailable');\n    restoredBytes += stored.bytes.byteLength;\n    if (restoredBytes > MAX_MCP_CONTENT_BYTES) throw new Error('MCP content exceeds native limit');\n    if (stored.mimeType !== link.data.mimeType) throw new Error('MCP attachment type mismatch');\n    if (image) {\n      let binary = '';\n      for (let offset = 0; offset < stored.bytes.length; offset += 8192)\n        binary += String.fromCharCode(...stored.bytes.subarray(offset, offset + 8192));\n      content.push({ type: 'image', data: btoa(binary), mimeType: stored.mimeType });\n    } else\n      content.push({\n        type: 'text',\n        text: new TextDecoder('utf-8', { fatal: true }).decode(stored.bytes),\n      });\n  }\n  return { ...result, content };\n};\n\nexport const readMcpAttachment = async (args: {\n  fetch: typeof fetch;\n  endpoint: { url: string; token: string | null };\n  uri: string;\n  signal?: AbortSignal;\n}): Promise<McpAttachmentIface | null> => {\n  const response = await args.fetch(args.endpoint.url, {\n    method: 'POST',\n    redirect: 'manual',\n    headers:\n      args.endpoint.token == null\n        ? { 'content-type': 'application/json' }\n        : { authorization: `Bearer ${args.endpoint.token}`, 'content-type': 'application/json' },\n    body: JSON.stringify({ uri: args.uri }),\n    signal: args.signal,\n  });\n  if (!response.ok) {\n    await response.body?.cancel();\n    return null;\n  }\n  const reader = response.body?.getReader();\n  if (reader == null) return null;\n  const chunks: Uint8Array[] = [];\n  let size = 0;\n  try {\n    for (;;) {\n      const next = await reader.read();\n      if (next.done) break;\n      size += next.value.byteLength;\n      if (size > MAX_MCP_CONTENT_BYTES) {\n        await reader.cancel();\n        throw new Error('MCP attachment exceeds limit');\n      }\n      chunks.push(next.value);\n    }\n  } finally {\n    reader.releaseLock();\n  }\n  const bytes = new Uint8Array(size);\n  let offset = 0;\n  for (const chunk of chunks) {\n    bytes.set(chunk, offset);\n    offset += chunk.byteLength;\n  }\n  return { bytes, mimeType: response.headers.get('content-type') ?? 'application/octet-stream' };\n};\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/modules/provider-ref.d.mts

@@ -0,0 +1,29 @@
+import * as z from 'zod';
+export declare enum ProviderRefKind {
+    Package = "package",
+    Bundle = "bundle"
+}
+export declare const packageProviderRefSchema: z.ZodObject<{
+    kind: z.ZodLiteral<ProviderRefKind.Package>;
+    specifier: z.ZodString;
+}, z.core.$strip>;
+export declare const bundleProviderRefSchema: z.ZodObject<{
+    kind: z.ZodLiteral<ProviderRefKind.Bundle>;
+    export: z.ZodString;
+}, z.core.$strip>;
+export declare const providerRefSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<ProviderRefKind.Package>;
+    specifier: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<ProviderRefKind.Bundle>;
+    export: z.ZodString;
+}, z.core.$strip>], "kind">;
+export type PackageProviderRefIface = z.infer<typeof packageProviderRefSchema>;
+export type BundleProviderRefIface = z.infer<typeof bundleProviderRefSchema>;
+export type ProviderRef = z.infer<typeof providerRefSchema>;
+export declare const packageRef: (specifier: string) => PackageProviderRefIface;
+export declare const bundleRef: (exportName: string) => BundleProviderRefIface;
+export declare const formatProviderRef: (ref: ProviderRef) => string;
+export declare const parseProviderRef: (text: string) => ProviderRef | null;
+export declare const providerRefsEqual: (a: ProviderRef, b: ProviderRef) => boolean;
+export declare const providerRefTextMatches: (text: string, ref: ProviderRef) => boolean;

package/dist/modules/provider-ref.mjs

@@ -0,0 +1,55 @@
+import * as z from "zod";
+var ProviderRefKind = /* @__PURE__ */ ((ProviderRefKind2) => {
+  ProviderRefKind2["Package"] = "package";
+  ProviderRefKind2["Bundle"] = "bundle";
+  return ProviderRefKind2;
+})(ProviderRefKind || {});
+const packageProviderRefSchema = z.object({
+  kind: z.literal("package" /* Package */),
+  specifier: z.string().min(1)
+});
+const bundleProviderRefSchema = z.object({
+  kind: z.literal("bundle" /* Bundle */),
+  export: z.string().min(1)
+});
+const providerRefSchema = z.discriminatedUnion("kind", [
+  packageProviderRefSchema,
+  bundleProviderRefSchema
+]);
+const packageRef = (specifier) => ({
+  kind: "package" /* Package */,
+  specifier
+});
+const bundleRef = (exportName) => ({
+  kind: "bundle" /* Bundle */,
+  export: exportName
+});
+const formatProviderRef = (ref) => ref.kind === "package" /* Package */ ? `package:${ref.specifier}` : `bundle:${ref.export}`;
+const parseProviderRef = (text) => {
+  const separator = text.indexOf(":");
+  if (separator <= 0) return null;
+  const kind = text.slice(0, separator);
+  const value = text.slice(separator + 1);
+  if (value.length === 0) return null;
+  if (kind === "package" /* Package */) return packageRef(value);
+  if (kind === "bundle" /* Bundle */) return bundleRef(value);
+  return null;
+};
+const providerRefsEqual = (a, b) => formatProviderRef(a) === formatProviderRef(b);
+const providerRefTextMatches = (text, ref) => {
+  const parsed = parseProviderRef(text);
+  return parsed != null && providerRefsEqual(parsed, ref);
+};
+export {
+  ProviderRefKind,
+  bundleProviderRefSchema,
+  bundleRef,
+  formatProviderRef,
+  packageProviderRefSchema,
+  packageRef,
+  parseProviderRef,
+  providerRefSchema,
+  providerRefTextMatches,
+  providerRefsEqual
+};
+//# sourceMappingURL=provider-ref.mjs.map

package/dist/modules/provider-ref.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/provider-ref.ts"],
+  "sourcesContent": ["import * as z from 'zod';\n\n// Provider implementation references. Installed packages use an import specifier\n// ('@finalai/final-agent-provider/harnesses/serverless-pi'); providers declared in\n// a definition's authored bundle are referenced by export name, scoped to the\n// revision the reference is stored with.\nexport enum ProviderRefKind {\n  Package = 'package',\n  Bundle = 'bundle',\n}\n\nexport const packageProviderRefSchema = z.object({\n  kind: z.literal(ProviderRefKind.Package),\n  specifier: z.string().min(1),\n});\n\nexport const bundleProviderRefSchema = z.object({\n  kind: z.literal(ProviderRefKind.Bundle),\n  export: z.string().min(1),\n});\n\nexport const providerRefSchema = z.discriminatedUnion('kind', [\n  packageProviderRefSchema,\n  bundleProviderRefSchema,\n]);\n\nexport type PackageProviderRefIface = z.infer<typeof packageProviderRefSchema>;\nexport type BundleProviderRefIface = z.infer<typeof bundleProviderRefSchema>;\nexport type ProviderRef = z.infer<typeof providerRefSchema>;\n\nexport const packageRef = (specifier: string): PackageProviderRefIface => ({\n  kind: ProviderRefKind.Package,\n  specifier,\n});\n\nexport const bundleRef = (exportName: string): BundleProviderRefIface => ({\n  kind: ProviderRefKind.Bundle,\n  export: exportName,\n});\n\n// Stable text form for telemetry, logs and the `harness_ref` / `provider_ref`\n// columns: 'package:<specifier>' or 'bundle:<export>'.\nexport const formatProviderRef = (ref: ProviderRef): string =>\n  ref.kind === ProviderRefKind.Package ? `package:${ref.specifier}` : `bundle:${ref.export}`;\n\nexport const parseProviderRef = (text: string): ProviderRef | null => {\n  const separator = text.indexOf(':');\n  if (separator <= 0) return null;\n  const kind = text.slice(0, separator);\n  const value = text.slice(separator + 1);\n  if (value.length === 0) return null;\n  if (kind === ProviderRefKind.Package) return packageRef(value);\n  if (kind === ProviderRefKind.Bundle) return bundleRef(value);\n  return null;\n};\n\nexport const providerRefsEqual = (a: ProviderRef, b: ProviderRef): boolean =>\n  formatProviderRef(a) === formatProviderRef(b);\n\nexport const providerRefTextMatches = (text: string, ref: ProviderRef): boolean => {\n  const parsed = parseProviderRef(text);\n  return parsed != null && providerRefsEqual(parsed, ref);\n};\n"],
+  "mappings": "AAAA,YAAY,OAAO;AAMZ,IAAK,kBAAL,kBAAKA,qBAAL;AACL,EAAAA,iBAAA,aAAU;AACV,EAAAA,iBAAA,YAAS;AAFC,SAAAA;AAAA,GAAA;AAKL,MAAM,2BAA2B,EAAE,OAAO;AAAA,EAC/C,MAAM,EAAE,QAAQ,uBAAuB;AAAA,EACvC,WAAW,EAAE,OAAO,EAAE,IAAI,CAAC;AAC7B,CAAC;AAEM,MAAM,0BAA0B,EAAE,OAAO;AAAA,EAC9C,MAAM,EAAE,QAAQ,qBAAsB;AAAA,EACtC,QAAQ,EAAE,OAAO,EAAE,IAAI,CAAC;AAC1B,CAAC;AAEM,MAAM,oBAAoB,EAAE,mBAAmB,QAAQ;AAAA,EAC5D;AAAA,EACA;AACF,CAAC;AAMM,MAAM,aAAa,CAAC,eAAgD;AAAA,EACzE,MAAM;AAAA,EACN;AACF;AAEO,MAAM,YAAY,CAAC,gBAAgD;AAAA,EACxE,MAAM;AAAA,EACN,QAAQ;AACV;AAIO,MAAM,oBAAoB,CAAC,QAChC,IAAI,SAAS,0BAA0B,WAAW,IAAI,SAAS,KAAK,UAAU,IAAI,MAAM;AAEnF,MAAM,mBAAmB,CAAC,SAAqC;AACpE,QAAM,YAAY,KAAK,QAAQ,GAAG;AAClC,MAAI,aAAa,EAAG,QAAO;AAC3B,QAAM,OAAO,KAAK,MAAM,GAAG,SAAS;AACpC,QAAM,QAAQ,KAAK,MAAM,YAAY,CAAC;AACtC,MAAI,MAAM,WAAW,EAAG,QAAO;AAC/B,MAAI,SAAS,wBAAyB,QAAO,WAAW,KAAK;AAC7D,MAAI,SAAS,sBAAwB,QAAO,UAAU,KAAK;AAC3D,SAAO;AACT;AAEO,MAAM,oBAAoB,CAAC,GAAgB,MAChD,kBAAkB,CAAC,MAAM,kBAAkB,CAAC;AAEvC,MAAM,yBAAyB,CAAC,MAAc,QAA8B;AACjF,QAAM,SAAS,iBAAiB,IAAI;AACpC,SAAO,UAAU,QAAQ,kBAAkB,QAAQ,GAAG;AACxD;",
+  "names": ["ProviderRefKind"]
+}

package/dist/modules/sandbox/bytes.d.mts

@@ -0,0 +1,9 @@
+export declare const utf8Encode: (text: string) => Uint8Array;
+export declare const utf8Decode: (bytes: Uint8Array) => string;
+export declare const concatBytes: (chunks: readonly Uint8Array[]) => Uint8Array;
+export declare const bytesToBase64: (bytes: Uint8Array) => string;
+export declare const base64ToBytes: (text: string) => Uint8Array;
+export declare const bytesToStream: (bytes: Uint8Array, chunkBytes?: number) => ReadableStream<Uint8Array>;
+export declare const readAllBytes: (stream: ReadableStream<Uint8Array>, abortSignal?: AbortSignal) => Promise<Uint8Array>;
+export declare const encodeSandboxText: (text: string, encoding?: string) => Uint8Array;
+export declare const decodeSandboxText: (bytes: Uint8Array, encoding?: string) => string;