@finalai/final-agent-provider 0.10.0 → 0.11.0

package/dist/modules/harnesses/serverless-final.mjs

@@ -1,88 +0,0 @@
-import {
-  AcpTransport,
-  CredentialDelivery,
-  HarnessTrustClass,
-  InferenceCredentialKind,
-  McpTransportKind,
-  PromptWhileRunning,
-  SandboxWire
-} from "@finalai/agent-provider";
-import * as z from "zod";
-import {
-  configObjectJson,
-  credentialsJson,
-  credentialsZod,
-  harnessBinding,
-  instructionsJson,
-  instructionsZod,
-  modelJson,
-  modelZod,
-  permissionModeJson,
-  PiPermissionMode,
-  reasoningJson,
-  ReasoningLevel,
-  reasoningZod,
-  skillsJson,
-  skillsZod
-} from "./config-fields.mjs";
-import { ModelVendor } from "./model-reference.mjs";
-import { PI_BASE_TOOLS } from "./serverless-pi.mjs";
-const SPECIFIER = "@finalai/final-agent-provider/harnesses/serverless-final";
-const FINAL_REASONING_LEVELS = [
-  ReasoningLevel.Low,
-  ReasoningLevel.Medium,
-  ReasoningLevel.High
-];
-const serverlessFinalConfigSchema = z.strictObject({
-  model: modelZod().optional(),
-  reasoning: reasoningZod(FINAL_REASONING_LEVELS).optional(),
-  credentials: credentialsZod(),
-  permissionMode: z.nativeEnum(PiPermissionMode).default(PiPermissionMode.Ask),
-  instructions: instructionsZod(),
-  skills: skillsZod()
-});
-const SERVERLESS_FINAL_CONFIG_JSON_SCHEMA = configObjectJson({
-  required: ["credentials"],
-  title: "Final harness (serverless)",
-  properties: {
-    model: modelJson(),
-    reasoning: reasoningJson(FINAL_REASONING_LEVELS),
-    credentials: credentialsJson(),
-    permissionMode: permissionModeJson(Object.values(PiPermissionMode), PiPermissionMode.Ask),
-    instructions: instructionsJson(),
-    skills: skillsJson()
-  }
-});
-const SERVERLESS_FINAL_DESCRIPTION = {
-  configSchema: SERVERLESS_FINAL_CONFIG_JSON_SCHEMA,
-  acp: {
-    transports: [AcpTransport.Relay, AcpTransport.Ws],
-    mcp: [McpTransportKind.Acp, McpTransportKind.Http]
-  },
-  baseTools: PI_BASE_TOOLS,
-  consumes: [SandboxWire.HandleRpc],
-  // The Final catalog through the LLM proxy (platform), or an organization's own
-  // OpenRouter-compatible key and base URL, as serverless-pi takes it.
-  inference: {
-    vendors: [ModelVendor.OpenRouter],
-    kinds: [InferenceCredentialKind.ApiKey, InferenceCredentialKind.Platform],
-    delivery: CredentialDelivery.PerRequest
-  },
-  // Final runs these on its own Workers.
-  trust: HarnessTrustClass.FirstParty,
-  supports: { observe: true, resumeReplay: true, fork: false, authorMeta: true },
-  // Same engine as serverless-pi (pi/engine.test.ts "injects a prompt accepted while
-  // running into the running work"); open asks are not re-raised across invocations.
-  promptWhileRunning: PromptWhileRunning.Inject,
-  sessionSurvivesDisconnect: false
-};
-const serverlessFinal = (config) => harnessBinding(SPECIFIER, config);
-export {
-  FINAL_REASONING_LEVELS,
-  SERVERLESS_FINAL_CONFIG_JSON_SCHEMA,
-  SERVERLESS_FINAL_DESCRIPTION,
-  SPECIFIER,
-  serverlessFinal,
-  serverlessFinalConfigSchema
-};
-//# sourceMappingURL=serverless-final.mjs.map

package/dist/modules/harnesses/serverless-final.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../../src/harnesses/serverless-final.ts"],
-  "sourcesContent": ["import {\n  AcpTransport,\n  CredentialDelivery,\n  HarnessTrustClass,\n  InferenceCredentialKind,\n  McpTransportKind,\n  PromptWhileRunning,\n  SandboxWire,\n  type HarnessDescriptionIface,\n  type JsonSchema,\n} from '@finalai/agent-provider';\nimport * as z from 'zod';\nimport {\n  configObjectJson,\n  credentialsJson,\n  credentialsZod,\n  harnessBinding,\n  instructionsJson,\n  instructionsZod,\n  modelJson,\n  modelZod,\n  permissionModeJson,\n  PiPermissionMode,\n  reasoningJson,\n  ReasoningLevel,\n  reasoningZod,\n  skillsJson,\n  skillsZod,\n  type CredentialsInput,\n  type HarnessBindingOutputIface,\n  type InstructionInput,\n  type SkillInput,\n} from \"./config-fields.mjs\";\nimport { ModelVendor } from \"./model-reference.mjs\";\nimport { PI_BASE_TOOLS } from \"./serverless-pi.mjs\";\n\n// The Final harness (Final's own Pi-derived loop, the one Home runs on) in the\n// same Durable Object runtime as serverless-pi; it differs only in program and\n// catalog.\n\nexport const SPECIFIER = '@finalai/final-agent-provider/harnesses/serverless-final';\n\nexport const FINAL_REASONING_LEVELS = [\n  ReasoningLevel.Low,\n  ReasoningLevel.Medium,\n  ReasoningLevel.High,\n] as const;\n\nexport const serverlessFinalConfigSchema = z.strictObject({\n  model: modelZod().optional(),\n  reasoning: reasoningZod(FINAL_REASONING_LEVELS).optional(),\n  credentials: credentialsZod(),\n  permissionMode: z.nativeEnum(PiPermissionMode).default(PiPermissionMode.Ask),\n  instructions: instructionsZod(),\n  skills: skillsZod(),\n});\n\nexport type ServerlessFinalConfigIface = z.output<typeof serverlessFinalConfigSchema>;\n\nexport const SERVERLESS_FINAL_CONFIG_JSON_SCHEMA: JsonSchema = configObjectJson({\n  required: ['credentials'],\n  title: 'Final harness (serverless)',\n  properties: {\n    model: modelJson(),\n    reasoning: reasoningJson(FINAL_REASONING_LEVELS),\n    credentials: credentialsJson(),\n    permissionMode: permissionModeJson(Object.values(PiPermissionMode), PiPermissionMode.Ask),\n    instructions: instructionsJson(),\n    skills: skillsJson(),\n  },\n});\n\nexport const SERVERLESS_FINAL_DESCRIPTION: HarnessDescriptionIface = {\n  configSchema: SERVERLESS_FINAL_CONFIG_JSON_SCHEMA,\n  acp: {\n    transports: [AcpTransport.Relay, AcpTransport.Ws],\n    mcp: [McpTransportKind.Acp, McpTransportKind.Http],\n  },\n  baseTools: PI_BASE_TOOLS,\n  consumes: [SandboxWire.HandleRpc],\n  // The Final catalog through the LLM proxy (platform), or an organization's own\n  // OpenRouter-compatible key and base URL, as serverless-pi takes it.\n  inference: {\n    vendors: [ModelVendor.OpenRouter],\n    kinds: [InferenceCredentialKind.ApiKey, InferenceCredentialKind.Platform],\n    delivery: CredentialDelivery.PerRequest,\n  },\n  // Final runs these on its own Workers.\n  trust: HarnessTrustClass.FirstParty,\n  supports: { observe: true, resumeReplay: true, fork: false, authorMeta: true },\n  // Same engine as serverless-pi (pi/engine.test.ts \"injects a prompt accepted while\n  // running into the running work\"); open asks are not re-raised across invocations.\n  promptWhileRunning: PromptWhileRunning.Inject,\n  sessionSurvivesDisconnect: false,\n};\n\nexport interface ServerlessFinalConfigInputIface {\n  model?: string;\n  reasoning?:\n    | (typeof FINAL_REASONING_LEVELS)[number]\n    | `${(typeof FINAL_REASONING_LEVELS)[number]}`;\n  credentials: CredentialsInput;\n  permissionMode?: PiPermissionMode | `${PiPermissionMode}`;\n  instructions?: InstructionInput[];\n  skills?: SkillInput[];\n}\n\nexport const serverlessFinal = (\n  config: ServerlessFinalConfigInputIface,\n): HarnessBindingOutputIface => harnessBinding(SPECIFIER, config);\n"],
-  "mappings": "AAAA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OAGK;AACP,YAAY,OAAO;AACnB;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OAKK;AACP,SAAS,mBAAmB;AAC5B,SAAS,qBAAqB;AAMvB,MAAM,YAAY;AAElB,MAAM,yBAAyB;AAAA,EACpC,eAAe;AAAA,EACf,eAAe;AAAA,EACf,eAAe;AACjB;AAEO,MAAM,8BAA8B,EAAE,aAAa;AAAA,EACxD,OAAO,SAAS,EAAE,SAAS;AAAA,EAC3B,WAAW,aAAa,sBAAsB,EAAE,SAAS;AAAA,EACzD,aAAa,eAAe;AAAA,EAC5B,gBAAgB,EAAE,WAAW,gBAAgB,EAAE,QAAQ,iBAAiB,GAAG;AAAA,EAC3E,cAAc,gBAAgB;AAAA,EAC9B,QAAQ,UAAU;AACpB,CAAC;AAIM,MAAM,sCAAkD,iBAAiB;AAAA,EAC9E,UAAU,CAAC,aAAa;AAAA,EACxB,OAAO;AAAA,EACP,YAAY;AAAA,IACV,OAAO,UAAU;AAAA,IACjB,WAAW,cAAc,sBAAsB;AAAA,IAC/C,aAAa,gBAAgB;AAAA,IAC7B,gBAAgB,mBAAmB,OAAO,OAAO,gBAAgB,GAAG,iBAAiB,GAAG;AAAA,IACxF,cAAc,iBAAiB;AAAA,IAC/B,QAAQ,WAAW;AAAA,EACrB;AACF,CAAC;AAEM,MAAM,+BAAwD;AAAA,EACnE,cAAc;AAAA,EACd,KAAK;AAAA,IACH,YAAY,CAAC,aAAa,OAAO,aAAa,EAAE;AAAA,IAChD,KAAK,CAAC,iBAAiB,KAAK,iBAAiB,IAAI;AAAA,EACnD;AAAA,EACA,WAAW;AAAA,EACX,UAAU,CAAC,YAAY,SAAS;AAAA;AAAA;AAAA,EAGhC,WAAW;AAAA,IACT,SAAS,CAAC,YAAY,UAAU;AAAA,IAChC,OAAO,CAAC,wBAAwB,QAAQ,wBAAwB,QAAQ;AAAA,IACxE,UAAU,mBAAmB;AAAA,EAC/B;AAAA;AAAA,EAEA,OAAO,kBAAkB;AAAA,EACzB,UAAU,EAAE,SAAS,MAAM,cAAc,MAAM,MAAM,OAAO,YAAY,KAAK;AAAA;AAAA;AAAA,EAG7E,oBAAoB,mBAAmB;AAAA,EACvC,2BAA2B;AAC7B;AAaO,MAAM,kBAAkB,CAC7B,WAC8B,eAAe,WAAW,MAAM;",
-  "names": []
-}

package/dist/modules/harnesses/serverless-nanocode-claude.d.mts

@@ -1,64 +0,0 @@
-import { type HarnessDescriptionIface, type JsonSchema } from '@finalai/agent-provider';
-import * as z from 'zod';
-import { ClaudePermissionMode, ReasoningLevel, type CredentialsInput, type HarnessBindingOutputIface, type InstructionInput, type SkillInput } from "./config-fields.mjs";
-export declare const SPECIFIER = "@finalai/final-agent-provider/harnesses/serverless-nanocode-claude";
-export declare const CLAUDE_REASONING_LEVELS: readonly [ReasoningLevel.Low, ReasoningLevel.Medium, ReasoningLevel.High, ReasoningLevel.Max];
-export declare const NANOCODE_CLAUDE_BASE_TOOLS: HarnessDescriptionIface['baseTools'];
-export declare const serverlessNanocodeClaudeConfigSchema: z.ZodObject<{
-    model: z.ZodOptional<z.ZodString>;
-    reasoning: z.ZodOptional<z.ZodEnum<typeof ReasoningLevel>>;
-    credentials: z.ZodObject<{
-        payer: z.ZodEnum<typeof import("@finalai/agent-provider").CredentialPayer>;
-        tryInOrder: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-            kind: z.ZodLiteral<import("@finalai/agent-provider").CredentialNodeKind.Subscription>;
-            owner: z.ZodEnum<typeof import("@finalai/agent-provider").CredentialOwner>;
-            vendor: z.ZodOptional<z.ZodString>;
-            pin: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>, z.ZodObject<{
-            kind: z.ZodLiteral<import("@finalai/agent-provider").CredentialNodeKind.ApiKey>;
-            secret: z.ZodString;
-            baseUrl: z.ZodOptional<z.ZodString>;
-            vendor: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>, z.ZodObject<{
-            pin: z.ZodOptional<z.ZodString>;
-            kind: z.ZodLiteral<import("@finalai/agent-provider").CredentialNodeKind.ApiKey>;
-            owner: z.ZodEnum<typeof import("@finalai/agent-provider").CredentialOwner>;
-            vendor: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>, z.ZodObject<{
-            kind: z.ZodLiteral<import("@finalai/agent-provider").CredentialNodeKind.Platform>;
-            budget: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>, z.ZodObject<{
-            kind: z.ZodLiteral<import("@finalai/agent-provider").CredentialNodeKind.HarnessOwned>;
-        }, z.core.$strip>, z.ZodObject<{
-            kind: z.ZodLiteral<import("@finalai/agent-provider").CredentialNodeKind.Custom>;
-            resolver: z.ZodString;
-            events: z.ZodDefault<z.ZodArray<z.ZodEnum<typeof import("@finalai/agent-provider").DynamicEvent>>>;
-        }, z.core.$strip>]>>;
-    }, z.core.$strip>;
-    permissionMode: z.ZodDefault<z.ZodEnum<typeof ClaudePermissionMode>>;
-    instructions: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        role: z.ZodEnum<typeof import("@finalai/agent-provider").InstructionRole>;
-        content: z.ZodString;
-        source: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>;
-    skills: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        key: z.ZodString;
-        description: z.ZodOptional<z.ZodString>;
-        files: z.ZodArray<z.ZodObject<{
-            path: z.ZodString;
-            content: z.ZodString;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>>;
-}, z.core.$strict>;
-export type ServerlessNanocodeClaudeConfigIface = z.output<typeof serverlessNanocodeClaudeConfigSchema>;
-export declare const SERVERLESS_NANOCODE_CLAUDE_CONFIG_JSON_SCHEMA: JsonSchema;
-export declare const SERVERLESS_NANOCODE_CLAUDE_DESCRIPTION: HarnessDescriptionIface;
-export interface ServerlessNanocodeClaudeConfigInputIface {
-    model?: string;
-    reasoning?: (typeof CLAUDE_REASONING_LEVELS)[number] | `${(typeof CLAUDE_REASONING_LEVELS)[number]}`;
-    credentials: CredentialsInput;
-    permissionMode?: ClaudePermissionMode | `${ClaudePermissionMode}`;
-    instructions?: InstructionInput[];
-    skills?: SkillInput[];
-}
-export declare const serverlessNanocodeClaude: (config: ServerlessNanocodeClaudeConfigInputIface) => HarnessBindingOutputIface;

package/dist/modules/harnesses/serverless-nanocode-claude.mjs

@@ -1,105 +0,0 @@
-import {
-  AcpTransport,
-  BaseCapability,
-  BaseToolProvision,
-  CredentialDelivery,
-  HarnessTrustClass,
-  InferenceCredentialKind,
-  McpTransportKind,
-  PromptWhileRunning,
-  SandboxWire
-} from "@finalai/agent-provider";
-import * as z from "zod";
-import {
-  ClaudePermissionMode,
-  configObjectJson,
-  credentialsJson,
-  credentialsZod,
-  harnessBinding,
-  instructionsJson,
-  instructionsZod,
-  modelJson,
-  modelZod,
-  permissionModeJson,
-  reasoningJson,
-  ReasoningLevel,
-  reasoningZod,
-  skillsJson,
-  skillsZod
-} from "./config-fields.mjs";
-import { ModelVendor } from "./model-reference.mjs";
-const SPECIFIER = "@finalai/final-agent-provider/harnesses/serverless-nanocode-claude";
-const CLAUDE_REASONING_LEVELS = [
-  ReasoningLevel.Low,
-  ReasoningLevel.Medium,
-  ReasoningLevel.High,
-  ReasoningLevel.Max
-];
-const NANOCODE_CLAUDE_BASE_TOOLS = {
-  [BaseCapability.Shell]: {
-    provision: BaseToolProvision.Bound,
-    nativeTools: ["Bash", "BashOutput"]
-  },
-  [BaseCapability.Files]: { provision: BaseToolProvision.Bound, nativeTools: ["Read", "Write"] }
-};
-const serverlessNanocodeClaudeConfigSchema = z.strictObject({
-  model: modelZod().optional(),
-  reasoning: reasoningZod(CLAUDE_REASONING_LEVELS).optional(),
-  credentials: credentialsZod(),
-  permissionMode: z.nativeEnum(ClaudePermissionMode).default(ClaudePermissionMode.Default),
-  instructions: instructionsZod(),
-  skills: skillsZod()
-});
-const SERVERLESS_NANOCODE_CLAUDE_CONFIG_JSON_SCHEMA = configObjectJson({
-  required: ["credentials"],
-  title: "Claude on nanocode (serverless)",
-  properties: {
-    model: modelJson(),
-    reasoning: reasoningJson(CLAUDE_REASONING_LEVELS),
-    credentials: credentialsJson(),
-    permissionMode: permissionModeJson(
-      Object.values(ClaudePermissionMode),
-      ClaudePermissionMode.Default
-    ),
-    instructions: instructionsJson(),
-    skills: skillsJson()
-  }
-});
-const SERVERLESS_NANOCODE_CLAUDE_DESCRIPTION = {
-  configSchema: SERVERLESS_NANOCODE_CLAUDE_CONFIG_JSON_SCHEMA,
-  acp: {
-    transports: [AcpTransport.Relay, AcpTransport.Ws],
-    mcp: [McpTransportKind.Acp, McpTransportKind.Http]
-  },
-  baseTools: NANOCODE_CLAUDE_BASE_TOOLS,
-  consumes: [SandboxWire.HandleRpc],
-  // Subscriptions are the Claude setup token, used as a bearer.
-  inference: {
-    vendors: [ModelVendor.Anthropic],
-    kinds: [
-      InferenceCredentialKind.Subscription,
-      InferenceCredentialKind.ApiKey,
-      InferenceCredentialKind.Platform
-    ],
-    delivery: CredentialDelivery.PerRequest
-  },
-  // Final runs these on its own Workers.
-  trust: HarnessTrustClass.FirstParty,
-  supports: { observe: true, resumeReplay: true, fork: false, authorMeta: true },
-  // Measured (agent-harness-workers nanocode/claude.test.ts "queues a prompt that arrives
-  // while a turn runs"): running, idle, running, idle. Open approvals are asked again
-  // with new ids after a lost invocation, so no disconnect survival yet.
-  promptWhileRunning: PromptWhileRunning.Queue,
-  sessionSurvivesDisconnect: false
-};
-const serverlessNanocodeClaude = (config) => harnessBinding(SPECIFIER, config);
-export {
-  CLAUDE_REASONING_LEVELS,
-  NANOCODE_CLAUDE_BASE_TOOLS,
-  SERVERLESS_NANOCODE_CLAUDE_CONFIG_JSON_SCHEMA,
-  SERVERLESS_NANOCODE_CLAUDE_DESCRIPTION,
-  SPECIFIER,
-  serverlessNanocodeClaude,
-  serverlessNanocodeClaudeConfigSchema
-};
-//# sourceMappingURL=serverless-nanocode-claude.mjs.map

package/dist/modules/harnesses/serverless-nanocode-claude.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../../src/harnesses/serverless-nanocode-claude.ts"],
-  "sourcesContent": ["import {\n  AcpTransport,\n  BaseCapability,\n  BaseToolProvision,\n  CredentialDelivery,\n  HarnessTrustClass,\n  InferenceCredentialKind,\n  McpTransportKind,\n  PromptWhileRunning,\n  SandboxWire,\n  type HarnessDescriptionIface,\n  type JsonSchema,\n} from '@finalai/agent-provider';\nimport * as z from 'zod';\nimport {\n  ClaudePermissionMode,\n  configObjectJson,\n  credentialsJson,\n  credentialsZod,\n  harnessBinding,\n  instructionsJson,\n  instructionsZod,\n  modelJson,\n  modelZod,\n  permissionModeJson,\n  reasoningJson,\n  ReasoningLevel,\n  reasoningZod,\n  skillsJson,\n  skillsZod,\n  type CredentialsInput,\n  type HarnessBindingOutputIface,\n  type InstructionInput,\n  type SkillInput,\n} from \"./config-fields.mjs\";\nimport { ModelVendor } from \"./model-reference.mjs\";\n\n// nanocode's Claude engine in the nanocode Durable Object script.\n\nexport const SPECIFIER = '@finalai/final-agent-provider/harnesses/serverless-nanocode-claude';\n\nexport const CLAUDE_REASONING_LEVELS = [\n  ReasoningLevel.Low,\n  ReasoningLevel.Medium,\n  ReasoningLevel.High,\n  ReasoningLevel.Max,\n] as const;\n\nexport const NANOCODE_CLAUDE_BASE_TOOLS: HarnessDescriptionIface['baseTools'] = {\n  [BaseCapability.Shell]: {\n    provision: BaseToolProvision.Bound,\n    nativeTools: ['Bash', 'BashOutput'],\n  },\n  [BaseCapability.Files]: { provision: BaseToolProvision.Bound, nativeTools: ['Read', 'Write'] },\n};\n\nexport const serverlessNanocodeClaudeConfigSchema = z.strictObject({\n  model: modelZod().optional(),\n  reasoning: reasoningZod(CLAUDE_REASONING_LEVELS).optional(),\n  credentials: credentialsZod(),\n  permissionMode: z.nativeEnum(ClaudePermissionMode).default(ClaudePermissionMode.Default),\n  instructions: instructionsZod(),\n  skills: skillsZod(),\n});\n\nexport type ServerlessNanocodeClaudeConfigIface = z.output<\n  typeof serverlessNanocodeClaudeConfigSchema\n>;\n\nexport const SERVERLESS_NANOCODE_CLAUDE_CONFIG_JSON_SCHEMA: JsonSchema = configObjectJson({\n  required: ['credentials'],\n  title: 'Claude on nanocode (serverless)',\n  properties: {\n    model: modelJson(),\n    reasoning: reasoningJson(CLAUDE_REASONING_LEVELS),\n    credentials: credentialsJson(),\n    permissionMode: permissionModeJson(\n      Object.values(ClaudePermissionMode),\n      ClaudePermissionMode.Default,\n    ),\n    instructions: instructionsJson(),\n    skills: skillsJson(),\n  },\n});\n\nexport const SERVERLESS_NANOCODE_CLAUDE_DESCRIPTION: HarnessDescriptionIface = {\n  configSchema: SERVERLESS_NANOCODE_CLAUDE_CONFIG_JSON_SCHEMA,\n  acp: {\n    transports: [AcpTransport.Relay, AcpTransport.Ws],\n    mcp: [McpTransportKind.Acp, McpTransportKind.Http],\n  },\n  baseTools: NANOCODE_CLAUDE_BASE_TOOLS,\n  consumes: [SandboxWire.HandleRpc],\n  // Subscriptions are the Claude setup token, used as a bearer.\n  inference: {\n    vendors: [ModelVendor.Anthropic],\n    kinds: [\n      InferenceCredentialKind.Subscription,\n      InferenceCredentialKind.ApiKey,\n      InferenceCredentialKind.Platform,\n    ],\n    delivery: CredentialDelivery.PerRequest,\n  },\n  // Final runs these on its own Workers.\n  trust: HarnessTrustClass.FirstParty,\n  supports: { observe: true, resumeReplay: true, fork: false, authorMeta: true },\n  // Measured (agent-harness-workers nanocode/claude.test.ts \"queues a prompt that arrives\n  // while a turn runs\"): running, idle, running, idle. Open approvals are asked again\n  // with new ids after a lost invocation, so no disconnect survival yet.\n  promptWhileRunning: PromptWhileRunning.Queue,\n  sessionSurvivesDisconnect: false,\n};\n\nexport interface ServerlessNanocodeClaudeConfigInputIface {\n  model?: string;\n  reasoning?:\n    | (typeof CLAUDE_REASONING_LEVELS)[number]\n    | `${(typeof CLAUDE_REASONING_LEVELS)[number]}`;\n  credentials: CredentialsInput;\n  permissionMode?: ClaudePermissionMode | `${ClaudePermissionMode}`;\n  instructions?: InstructionInput[];\n  skills?: SkillInput[];\n}\n\nexport const serverlessNanocodeClaude = (\n  config: ServerlessNanocodeClaudeConfigInputIface,\n): HarnessBindingOutputIface => harnessBinding(SPECIFIER, config);\n"],
-  "mappings": "AAAA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OAGK;AACP,YAAY,OAAO;AACnB;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OAKK;AACP,SAAS,mBAAmB;AAIrB,MAAM,YAAY;AAElB,MAAM,0BAA0B;AAAA,EACrC,eAAe;AAAA,EACf,eAAe;AAAA,EACf,eAAe;AAAA,EACf,eAAe;AACjB;AAEO,MAAM,6BAAmE;AAAA,EAC9E,CAAC,eAAe,KAAK,GAAG;AAAA,IACtB,WAAW,kBAAkB;AAAA,IAC7B,aAAa,CAAC,QAAQ,YAAY;AAAA,EACpC;AAAA,EACA,CAAC,eAAe,KAAK,GAAG,EAAE,WAAW,kBAAkB,OAAO,aAAa,CAAC,QAAQ,OAAO,EAAE;AAC/F;AAEO,MAAM,uCAAuC,EAAE,aAAa;AAAA,EACjE,OAAO,SAAS,EAAE,SAAS;AAAA,EAC3B,WAAW,aAAa,uBAAuB,EAAE,SAAS;AAAA,EAC1D,aAAa,eAAe;AAAA,EAC5B,gBAAgB,EAAE,WAAW,oBAAoB,EAAE,QAAQ,qBAAqB,OAAO;AAAA,EACvF,cAAc,gBAAgB;AAAA,EAC9B,QAAQ,UAAU;AACpB,CAAC;AAMM,MAAM,gDAA4D,iBAAiB;AAAA,EACxF,UAAU,CAAC,aAAa;AAAA,EACxB,OAAO;AAAA,EACP,YAAY;AAAA,IACV,OAAO,UAAU;AAAA,IACjB,WAAW,cAAc,uBAAuB;AAAA,IAChD,aAAa,gBAAgB;AAAA,IAC7B,gBAAgB;AAAA,MACd,OAAO,OAAO,oBAAoB;AAAA,MAClC,qBAAqB;AAAA,IACvB;AAAA,IACA,cAAc,iBAAiB;AAAA,IAC/B,QAAQ,WAAW;AAAA,EACrB;AACF,CAAC;AAEM,MAAM,yCAAkE;AAAA,EAC7E,cAAc;AAAA,EACd,KAAK;AAAA,IACH,YAAY,CAAC,aAAa,OAAO,aAAa,EAAE;AAAA,IAChD,KAAK,CAAC,iBAAiB,KAAK,iBAAiB,IAAI;AAAA,EACnD;AAAA,EACA,WAAW;AAAA,EACX,UAAU,CAAC,YAAY,SAAS;AAAA;AAAA,EAEhC,WAAW;AAAA,IACT,SAAS,CAAC,YAAY,SAAS;AAAA,IAC/B,OAAO;AAAA,MACL,wBAAwB;AAAA,MACxB,wBAAwB;AAAA,MACxB,wBAAwB;AAAA,IAC1B;AAAA,IACA,UAAU,mBAAmB;AAAA,EAC/B;AAAA;AAAA,EAEA,OAAO,kBAAkB;AAAA,EACzB,UAAU,EAAE,SAAS,MAAM,cAAc,MAAM,MAAM,OAAO,YAAY,KAAK;AAAA;AAAA;AAAA;AAAA,EAI7E,oBAAoB,mBAAmB;AAAA,EACvC,2BAA2B;AAC7B;AAaO,MAAM,2BAA2B,CACtC,WAC8B,eAAe,WAAW,MAAM;",
-  "names": []
-}

package/dist/modules/harnesses/serverless-nanocode-codex.d.mts

@@ -1,66 +0,0 @@
-import { type HarnessDescriptionIface, type JsonSchema } from '@finalai/agent-provider';
-import * as z from 'zod';
-import { CodexApprovalPolicy, CodexApprovalsReviewer, ReasoningLevel, type CredentialsInput, type HarnessBindingOutputIface, type InstructionInput, type SkillInput } from "./config-fields.mjs";
-export declare const SPECIFIER = "@finalai/final-agent-provider/harnesses/serverless-nanocode-codex";
-export declare const CODEX_REASONING_LEVELS: readonly [ReasoningLevel.Low, ReasoningLevel.Medium, ReasoningLevel.High, ReasoningLevel.Max];
-export declare const CODEX_BASE_TOOLS: HarnessDescriptionIface['baseTools'];
-export declare const serverlessNanocodeCodexConfigSchema: z.ZodObject<{
-    model: z.ZodOptional<z.ZodString>;
-    reasoning: z.ZodOptional<z.ZodEnum<typeof ReasoningLevel>>;
-    credentials: z.ZodObject<{
-        payer: z.ZodEnum<typeof import("@finalai/agent-provider").CredentialPayer>;
-        tryInOrder: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-            kind: z.ZodLiteral<import("@finalai/agent-provider").CredentialNodeKind.Subscription>;
-            owner: z.ZodEnum<typeof import("@finalai/agent-provider").CredentialOwner>;
-            vendor: z.ZodOptional<z.ZodString>;
-            pin: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>, z.ZodObject<{
-            kind: z.ZodLiteral<import("@finalai/agent-provider").CredentialNodeKind.ApiKey>;
-            secret: z.ZodString;
-            baseUrl: z.ZodOptional<z.ZodString>;
-            vendor: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>, z.ZodObject<{
-            pin: z.ZodOptional<z.ZodString>;
-            kind: z.ZodLiteral<import("@finalai/agent-provider").CredentialNodeKind.ApiKey>;
-            owner: z.ZodEnum<typeof import("@finalai/agent-provider").CredentialOwner>;
-            vendor: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>, z.ZodObject<{
-            kind: z.ZodLiteral<import("@finalai/agent-provider").CredentialNodeKind.Platform>;
-            budget: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>, z.ZodObject<{
-            kind: z.ZodLiteral<import("@finalai/agent-provider").CredentialNodeKind.HarnessOwned>;
-        }, z.core.$strip>, z.ZodObject<{
-            kind: z.ZodLiteral<import("@finalai/agent-provider").CredentialNodeKind.Custom>;
-            resolver: z.ZodString;
-            events: z.ZodDefault<z.ZodArray<z.ZodEnum<typeof import("@finalai/agent-provider").DynamicEvent>>>;
-        }, z.core.$strip>]>>;
-    }, z.core.$strip>;
-    approvalPolicy: z.ZodDefault<z.ZodEnum<typeof CodexApprovalPolicy>>;
-    approvalsReviewer: z.ZodDefault<z.ZodEnum<typeof CodexApprovalsReviewer>>;
-    instructions: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        role: z.ZodEnum<typeof import("@finalai/agent-provider").InstructionRole>;
-        content: z.ZodString;
-        source: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>;
-    skills: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        key: z.ZodString;
-        description: z.ZodOptional<z.ZodString>;
-        files: z.ZodArray<z.ZodObject<{
-            path: z.ZodString;
-            content: z.ZodString;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>>;
-}, z.core.$strict>;
-export type ServerlessNanocodeCodexConfigIface = z.output<typeof serverlessNanocodeCodexConfigSchema>;
-export declare const SERVERLESS_NANOCODE_CODEX_CONFIG_JSON_SCHEMA: JsonSchema;
-export declare const SERVERLESS_NANOCODE_CODEX_DESCRIPTION: HarnessDescriptionIface;
-export interface ServerlessNanocodeCodexConfigInputIface {
-    model?: string;
-    reasoning?: (typeof CODEX_REASONING_LEVELS)[number] | `${(typeof CODEX_REASONING_LEVELS)[number]}`;
-    credentials: CredentialsInput;
-    approvalPolicy?: CodexApprovalPolicy | `${CodexApprovalPolicy}`;
-    approvalsReviewer?: CodexApprovalsReviewer | `${CodexApprovalsReviewer}`;
-    instructions?: InstructionInput[];
-    skills?: SkillInput[];
-}
-export declare const serverlessNanocodeCodex: (config: ServerlessNanocodeCodexConfigInputIface) => HarnessBindingOutputIface;

package/dist/modules/harnesses/serverless-nanocode-codex.mjs

@@ -1,113 +0,0 @@
-import {
-  AcpTransport,
-  BaseCapability,
-  BaseToolProvision,
-  CredentialDelivery,
-  HarnessTrustClass,
-  InferenceCredentialKind,
-  McpTransportKind,
-  PromptWhileRunning,
-  SandboxWire
-} from "@finalai/agent-provider";
-import * as z from "zod";
-import {
-  CodexApprovalPolicy,
-  CodexApprovalsReviewer,
-  configObjectJson,
-  credentialsJson,
-  credentialsZod,
-  harnessBinding,
-  instructionsJson,
-  instructionsZod,
-  modelJson,
-  modelZod,
-  permissionModeJson,
-  reasoningJson,
-  ReasoningLevel,
-  reasoningZod,
-  skillsJson,
-  skillsZod
-} from "./config-fields.mjs";
-import { ModelVendor } from "./model-reference.mjs";
-const SPECIFIER = "@finalai/final-agent-provider/harnesses/serverless-nanocode-codex";
-const CODEX_REASONING_LEVELS = [
-  ReasoningLevel.Low,
-  ReasoningLevel.Medium,
-  ReasoningLevel.High,
-  ReasoningLevel.Max
-];
-const CODEX_BASE_TOOLS = {
-  [BaseCapability.Shell]: {
-    provision: BaseToolProvision.Bound,
-    nativeTools: ["exec_command", "write_stdin"]
-  },
-  [BaseCapability.Files]: {
-    provision: BaseToolProvision.Bound,
-    nativeTools: ["apply_patch", "view_image"]
-  }
-};
-const serverlessNanocodeCodexConfigSchema = z.strictObject({
-  model: modelZod().optional(),
-  reasoning: reasoningZod(CODEX_REASONING_LEVELS).optional(),
-  credentials: credentialsZod(),
-  approvalPolicy: z.nativeEnum(CodexApprovalPolicy).default(CodexApprovalPolicy.OnRequest),
-  approvalsReviewer: z.nativeEnum(CodexApprovalsReviewer).default(CodexApprovalsReviewer.User),
-  instructions: instructionsZod(),
-  skills: skillsZod()
-});
-const SERVERLESS_NANOCODE_CODEX_CONFIG_JSON_SCHEMA = configObjectJson({
-  required: ["credentials"],
-  title: "Codex on nanocode (serverless)",
-  properties: {
-    model: modelJson(),
-    reasoning: reasoningJson(CODEX_REASONING_LEVELS),
-    credentials: credentialsJson(),
-    approvalPolicy: permissionModeJson(
-      Object.values(CodexApprovalPolicy),
-      CodexApprovalPolicy.OnRequest
-    ),
-    approvalsReviewer: permissionModeJson(
-      Object.values(CodexApprovalsReviewer),
-      CodexApprovalsReviewer.User
-    ),
-    instructions: instructionsJson(),
-    skills: skillsJson()
-  }
-});
-const SERVERLESS_NANOCODE_CODEX_DESCRIPTION = {
-  configSchema: SERVERLESS_NANOCODE_CODEX_CONFIG_JSON_SCHEMA,
-  acp: {
-    transports: [AcpTransport.Relay, AcpTransport.Ws],
-    mcp: [McpTransportKind.Acp, McpTransportKind.Http]
-  },
-  baseTools: CODEX_BASE_TOOLS,
-  consumes: [SandboxWire.HandleRpc],
-  inference: {
-    vendors: [ModelVendor.OpenAI],
-    kinds: [
-      InferenceCredentialKind.Subscription,
-      InferenceCredentialKind.ApiKey,
-      InferenceCredentialKind.Platform
-    ],
-    delivery: CredentialDelivery.PerRequest
-  },
-  // Final runs these on its own Workers.
-  trust: HarnessTrustClass.FirstParty,
-  supports: { observe: true, resumeReplay: true, fork: false, authorMeta: true },
-  // Measured (agent-harness-workers nanocode/codex.test.ts "steers a prompt that arrives
-  // while the turn runs into it"); open approvals are asked again with new ids after a
-  // lost invocation, so no disconnect survival yet.
-  promptWhileRunning: PromptWhileRunning.Inject,
-  sessionSurvivesDisconnect: false
-};
-const serverlessNanocodeCodex = (config) => harnessBinding(SPECIFIER, config);
-export {
-  CODEX_BASE_TOOLS,
-  CODEX_REASONING_LEVELS,
-  SERVERLESS_NANOCODE_CODEX_CONFIG_JSON_SCHEMA,
-  SERVERLESS_NANOCODE_CODEX_DESCRIPTION,
-  SPECIFIER,
-  serverlessNanocodeCodex,
-  serverlessNanocodeCodexConfigSchema
-};
-//# sourceMappingURL=serverless-nanocode-codex.mjs.map

package/dist/modules/harnesses/serverless-nanocode-codex.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../../src/harnesses/serverless-nanocode-codex.ts"],
-  "sourcesContent": ["import {\n  AcpTransport,\n  BaseCapability,\n  BaseToolProvision,\n  CredentialDelivery,\n  HarnessTrustClass,\n  InferenceCredentialKind,\n  McpTransportKind,\n  PromptWhileRunning,\n  SandboxWire,\n  type HarnessDescriptionIface,\n  type JsonSchema,\n} from '@finalai/agent-provider';\nimport * as z from 'zod';\nimport {\n  CodexApprovalPolicy,\n  CodexApprovalsReviewer,\n  configObjectJson,\n  credentialsJson,\n  credentialsZod,\n  harnessBinding,\n  instructionsJson,\n  instructionsZod,\n  modelJson,\n  modelZod,\n  permissionModeJson,\n  reasoningJson,\n  ReasoningLevel,\n  reasoningZod,\n  skillsJson,\n  skillsZod,\n  type CredentialsInput,\n  type HarnessBindingOutputIface,\n  type InstructionInput,\n  type SkillInput,\n} from \"./config-fields.mjs\";\nimport { ModelVendor } from \"./model-reference.mjs\";\n\n// nanocode's Codex engine (Rust \u2192 wasm) in the nanocode Durable Object script.\n// Responses Lite models only; ChatGPT subscriptions go through the session\n// service relay because chatgpt.com blocks Workers egress.\n\nexport const SPECIFIER = '@finalai/final-agent-provider/harnesses/serverless-nanocode-codex';\n\n// The final://schemas/reasoning fragment has no xhigh/ultra yet; nanocode's\n// policies accept the rest.\nexport const CODEX_REASONING_LEVELS = [\n  ReasoningLevel.Low,\n  ReasoningLevel.Medium,\n  ReasoningLevel.High,\n  ReasoningLevel.Max,\n] as const;\n\nexport const CODEX_BASE_TOOLS: HarnessDescriptionIface['baseTools'] = {\n  [BaseCapability.Shell]: {\n    provision: BaseToolProvision.Bound,\n    nativeTools: ['exec_command', 'write_stdin'],\n  },\n  [BaseCapability.Files]: {\n    provision: BaseToolProvision.Bound,\n    nativeTools: ['apply_patch', 'view_image'],\n  },\n};\n\nexport const serverlessNanocodeCodexConfigSchema = z.strictObject({\n  model: modelZod().optional(),\n  reasoning: reasoningZod(CODEX_REASONING_LEVELS).optional(),\n  credentials: credentialsZod(),\n  approvalPolicy: z.nativeEnum(CodexApprovalPolicy).default(CodexApprovalPolicy.OnRequest),\n  approvalsReviewer: z.nativeEnum(CodexApprovalsReviewer).default(CodexApprovalsReviewer.User),\n  instructions: instructionsZod(),\n  skills: skillsZod(),\n});\n\nexport type ServerlessNanocodeCodexConfigIface = z.output<\n  typeof serverlessNanocodeCodexConfigSchema\n>;\n\nexport const SERVERLESS_NANOCODE_CODEX_CONFIG_JSON_SCHEMA: JsonSchema = configObjectJson({\n  required: ['credentials'],\n  title: 'Codex on nanocode (serverless)',\n  properties: {\n    model: modelJson(),\n    reasoning: reasoningJson(CODEX_REASONING_LEVELS),\n    credentials: credentialsJson(),\n    approvalPolicy: permissionModeJson(\n      Object.values(CodexApprovalPolicy),\n      CodexApprovalPolicy.OnRequest,\n    ),\n    approvalsReviewer: permissionModeJson(\n      Object.values(CodexApprovalsReviewer),\n      CodexApprovalsReviewer.User,\n    ),\n    instructions: instructionsJson(),\n    skills: skillsJson(),\n  },\n});\n\nexport const SERVERLESS_NANOCODE_CODEX_DESCRIPTION: HarnessDescriptionIface = {\n  configSchema: SERVERLESS_NANOCODE_CODEX_CONFIG_JSON_SCHEMA,\n  acp: {\n    transports: [AcpTransport.Relay, AcpTransport.Ws],\n    mcp: [McpTransportKind.Acp, McpTransportKind.Http],\n  },\n  baseTools: CODEX_BASE_TOOLS,\n  consumes: [SandboxWire.HandleRpc],\n  inference: {\n    vendors: [ModelVendor.OpenAI],\n    kinds: [\n      InferenceCredentialKind.Subscription,\n      InferenceCredentialKind.ApiKey,\n      InferenceCredentialKind.Platform,\n    ],\n    delivery: CredentialDelivery.PerRequest,\n  },\n  // Final runs these on its own Workers.\n  trust: HarnessTrustClass.FirstParty,\n  supports: { observe: true, resumeReplay: true, fork: false, authorMeta: true },\n  // Measured (agent-harness-workers nanocode/codex.test.ts \"steers a prompt that arrives\n  // while the turn runs into it\"); open approvals are asked again with new ids after a\n  // lost invocation, so no disconnect survival yet.\n  promptWhileRunning: PromptWhileRunning.Inject,\n  sessionSurvivesDisconnect: false,\n};\n\nexport interface ServerlessNanocodeCodexConfigInputIface {\n  model?: string;\n  reasoning?:\n    | (typeof CODEX_REASONING_LEVELS)[number]\n    | `${(typeof CODEX_REASONING_LEVELS)[number]}`;\n  credentials: CredentialsInput;\n  approvalPolicy?: CodexApprovalPolicy | `${CodexApprovalPolicy}`;\n  approvalsReviewer?: CodexApprovalsReviewer | `${CodexApprovalsReviewer}`;\n  instructions?: InstructionInput[];\n  skills?: SkillInput[];\n}\n\nexport const serverlessNanocodeCodex = (\n  config: ServerlessNanocodeCodexConfigInputIface,\n): HarnessBindingOutputIface => harnessBinding(SPECIFIER, config);\n"],
-  "mappings": "AAAA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OAGK;AACP,YAAY,OAAO;AACnB;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OAKK;AACP,SAAS,mBAAmB;AAMrB,MAAM,YAAY;AAIlB,MAAM,yBAAyB;AAAA,EACpC,eAAe;AAAA,EACf,eAAe;AAAA,EACf,eAAe;AAAA,EACf,eAAe;AACjB;AAEO,MAAM,mBAAyD;AAAA,EACpE,CAAC,eAAe,KAAK,GAAG;AAAA,IACtB,WAAW,kBAAkB;AAAA,IAC7B,aAAa,CAAC,gBAAgB,aAAa;AAAA,EAC7C;AAAA,EACA,CAAC,eAAe,KAAK,GAAG;AAAA,IACtB,WAAW,kBAAkB;AAAA,IAC7B,aAAa,CAAC,eAAe,YAAY;AAAA,EAC3C;AACF;AAEO,MAAM,sCAAsC,EAAE,aAAa;AAAA,EAChE,OAAO,SAAS,EAAE,SAAS;AAAA,EAC3B,WAAW,aAAa,sBAAsB,EAAE,SAAS;AAAA,EACzD,aAAa,eAAe;AAAA,EAC5B,gBAAgB,EAAE,WAAW,mBAAmB,EAAE,QAAQ,oBAAoB,SAAS;AAAA,EACvF,mBAAmB,EAAE,WAAW,sBAAsB,EAAE,QAAQ,uBAAuB,IAAI;AAAA,EAC3F,cAAc,gBAAgB;AAAA,EAC9B,QAAQ,UAAU;AACpB,CAAC;AAMM,MAAM,+CAA2D,iBAAiB;AAAA,EACvF,UAAU,CAAC,aAAa;AAAA,EACxB,OAAO;AAAA,EACP,YAAY;AAAA,IACV,OAAO,UAAU;AAAA,IACjB,WAAW,cAAc,sBAAsB;AAAA,IAC/C,aAAa,gBAAgB;AAAA,IAC7B,gBAAgB;AAAA,MACd,OAAO,OAAO,mBAAmB;AAAA,MACjC,oBAAoB;AAAA,IACtB;AAAA,IACA,mBAAmB;AAAA,MACjB,OAAO,OAAO,sBAAsB;AAAA,MACpC,uBAAuB;AAAA,IACzB;AAAA,IACA,cAAc,iBAAiB;AAAA,IAC/B,QAAQ,WAAW;AAAA,EACrB;AACF,CAAC;AAEM,MAAM,wCAAiE;AAAA,EAC5E,cAAc;AAAA,EACd,KAAK;AAAA,IACH,YAAY,CAAC,aAAa,OAAO,aAAa,EAAE;AAAA,IAChD,KAAK,CAAC,iBAAiB,KAAK,iBAAiB,IAAI;AAAA,EACnD;AAAA,EACA,WAAW;AAAA,EACX,UAAU,CAAC,YAAY,SAAS;AAAA,EAChC,WAAW;AAAA,IACT,SAAS,CAAC,YAAY,MAAM;AAAA,IAC5B,OAAO;AAAA,MACL,wBAAwB;AAAA,MACxB,wBAAwB;AAAA,MACxB,wBAAwB;AAAA,IAC1B;AAAA,IACA,UAAU,mBAAmB;AAAA,EAC/B;AAAA;AAAA,EAEA,OAAO,kBAAkB;AAAA,EACzB,UAAU,EAAE,SAAS,MAAM,cAAc,MAAM,MAAM,OAAO,YAAY,KAAK;AAAA;AAAA;AAAA;AAAA,EAI7E,oBAAoB,mBAAmB;AAAA,EACvC,2BAA2B;AAC7B;AAcO,MAAM,0BAA0B,CACrC,WAC8B,eAAe,WAAW,MAAM;",
-  "names": []
-}

package/dist/modules/harnesses/serverless-pi.d.mts

@@ -1,64 +0,0 @@
-import { type HarnessDescriptionIface, type JsonSchema } from '@finalai/agent-provider';
-import * as z from 'zod';
-import { PiPermissionMode, ReasoningLevel, type CredentialsInput, type HarnessBindingOutputIface, type InstructionInput, type SkillInput } from "./config-fields.mjs";
-export declare const SPECIFIER = "@finalai/final-agent-provider/harnesses/serverless-pi";
-export declare const PI_REASONING_LEVELS: readonly [ReasoningLevel.None, ReasoningLevel.Minimal, ReasoningLevel.Low, ReasoningLevel.Medium, ReasoningLevel.High];
-export declare const PI_BASE_TOOLS: HarnessDescriptionIface['baseTools'];
-export declare const serverlessPiConfigSchema: z.ZodObject<{
-    model: z.ZodOptional<z.ZodString>;
-    reasoning: z.ZodOptional<z.ZodEnum<typeof ReasoningLevel>>;
-    credentials: z.ZodObject<{
-        payer: z.ZodEnum<typeof import("@finalai/agent-provider").CredentialPayer>;
-        tryInOrder: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-            kind: z.ZodLiteral<import("@finalai/agent-provider").CredentialNodeKind.Subscription>;
-            owner: z.ZodEnum<typeof import("@finalai/agent-provider").CredentialOwner>;
-            vendor: z.ZodOptional<z.ZodString>;
-            pin: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>, z.ZodObject<{
-            kind: z.ZodLiteral<import("@finalai/agent-provider").CredentialNodeKind.ApiKey>;
-            secret: z.ZodString;
-            baseUrl: z.ZodOptional<z.ZodString>;
-            vendor: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>, z.ZodObject<{
-            pin: z.ZodOptional<z.ZodString>;
-            kind: z.ZodLiteral<import("@finalai/agent-provider").CredentialNodeKind.ApiKey>;
-            owner: z.ZodEnum<typeof import("@finalai/agent-provider").CredentialOwner>;
-            vendor: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>, z.ZodObject<{
-            kind: z.ZodLiteral<import("@finalai/agent-provider").CredentialNodeKind.Platform>;
-            budget: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>, z.ZodObject<{
-            kind: z.ZodLiteral<import("@finalai/agent-provider").CredentialNodeKind.HarnessOwned>;
-        }, z.core.$strip>, z.ZodObject<{
-            kind: z.ZodLiteral<import("@finalai/agent-provider").CredentialNodeKind.Custom>;
-            resolver: z.ZodString;
-            events: z.ZodDefault<z.ZodArray<z.ZodEnum<typeof import("@finalai/agent-provider").DynamicEvent>>>;
-        }, z.core.$strip>]>>;
-    }, z.core.$strip>;
-    permissionMode: z.ZodDefault<z.ZodEnum<typeof PiPermissionMode>>;
-    instructions: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        role: z.ZodEnum<typeof import("@finalai/agent-provider").InstructionRole>;
-        content: z.ZodString;
-        source: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>;
-    skills: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        key: z.ZodString;
-        description: z.ZodOptional<z.ZodString>;
-        files: z.ZodArray<z.ZodObject<{
-            path: z.ZodString;
-            content: z.ZodString;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>>;
-}, z.core.$strict>;
-export type ServerlessPiConfigIface = z.output<typeof serverlessPiConfigSchema>;
-export declare const SERVERLESS_PI_CONFIG_JSON_SCHEMA: JsonSchema;
-export declare const SERVERLESS_PI_DESCRIPTION: HarnessDescriptionIface;
-export interface ServerlessPiConfigInputIface {
-    model?: string;
-    reasoning?: (typeof PI_REASONING_LEVELS)[number] | `${(typeof PI_REASONING_LEVELS)[number]}`;
-    credentials: CredentialsInput;
-    permissionMode?: PiPermissionMode | `${PiPermissionMode}`;
-    instructions?: InstructionInput[];
-    skills?: SkillInput[];
-}
-export declare const serverlessPi: (config: ServerlessPiConfigInputIface) => HarnessBindingOutputIface;

package/dist/modules/harnesses/serverless-pi.mjs

@@ -1,98 +0,0 @@
-import {
-  AcpTransport,
-  BaseCapability,
-  BaseToolProvision,
-  CredentialDelivery,
-  HarnessTrustClass,
-  InferenceCredentialKind,
-  McpTransportKind,
-  PromptWhileRunning,
-  SandboxWire
-} from "@finalai/agent-provider";
-import * as z from "zod";
-import {
-  configObjectJson,
-  credentialsJson,
-  credentialsZod,
-  harnessBinding,
-  instructionsJson,
-  instructionsZod,
-  modelJson,
-  modelZod,
-  permissionModeJson,
-  PiPermissionMode,
-  reasoningJson,
-  ReasoningLevel,
-  reasoningZod,
-  skillsJson,
-  skillsZod
-} from "./config-fields.mjs";
-import { ModelVendor } from "./model-reference.mjs";
-const SPECIFIER = "@finalai/final-agent-provider/harnesses/serverless-pi";
-const PI_REASONING_LEVELS = [
-  ReasoningLevel.None,
-  ReasoningLevel.Minimal,
-  ReasoningLevel.Low,
-  ReasoningLevel.Medium,
-  ReasoningLevel.High
-];
-const PI_BASE_TOOLS = {
-  [BaseCapability.Shell]: { provision: BaseToolProvision.Bound, nativeTools: ["bash"] },
-  [BaseCapability.Files]: {
-    provision: BaseToolProvision.Bound,
-    nativeTools: ["read", "write", "edit", "grep", "find", "ls"]
-  }
-};
-const serverlessPiConfigSchema = z.strictObject({
-  model: modelZod().optional(),
-  reasoning: reasoningZod(PI_REASONING_LEVELS).optional(),
-  credentials: credentialsZod(),
-  permissionMode: z.nativeEnum(PiPermissionMode).default(PiPermissionMode.Ask),
-  instructions: instructionsZod(),
-  skills: skillsZod()
-});
-const SERVERLESS_PI_CONFIG_JSON_SCHEMA = configObjectJson({
-  required: ["credentials"],
-  title: "Pi (serverless)",
-  properties: {
-    model: modelJson(),
-    reasoning: reasoningJson(PI_REASONING_LEVELS),
-    credentials: credentialsJson(),
-    permissionMode: permissionModeJson(Object.values(PiPermissionMode), PiPermissionMode.Ask),
-    instructions: instructionsJson(),
-    skills: skillsJson()
-  }
-});
-const SERVERLESS_PI_DESCRIPTION = {
-  configSchema: SERVERLESS_PI_CONFIG_JSON_SCHEMA,
-  acp: {
-    transports: [AcpTransport.Relay, AcpTransport.Ws],
-    mcp: [McpTransportKind.Acp, McpTransportKind.Http]
-  },
-  baseTools: PI_BASE_TOOLS,
-  consumes: [SandboxWire.HandleRpc],
-  inference: {
-    vendors: [ModelVendor.OpenRouter, ModelVendor.OpenAI, ModelVendor.Anthropic],
-    kinds: [InferenceCredentialKind.ApiKey, InferenceCredentialKind.Platform],
-    delivery: CredentialDelivery.PerRequest
-  },
-  // Final runs these on its own Workers.
-  trust: HarnessTrustClass.FirstParty,
-  supports: { observe: true, resumeReplay: true, fork: false, authorMeta: true },
-  // Measured (agent-harness-workers pi/engine.test.ts "injects a prompt accepted while
-  // running into the running work"): a steer joins the running run. Across a lost
-  // invocation an open ask is not re-raised with its id, so no disconnect survival yet.
-  promptWhileRunning: PromptWhileRunning.Inject,
-  sessionSurvivesDisconnect: false
-};
-const serverlessPi = (config) => harnessBinding(SPECIFIER, config);
-export {
-  PI_BASE_TOOLS,
-  PI_REASONING_LEVELS,
-  SERVERLESS_PI_CONFIG_JSON_SCHEMA,
-  SERVERLESS_PI_DESCRIPTION,
-  SPECIFIER,
-  serverlessPi,
-  serverlessPiConfigSchema
-};
-//# sourceMappingURL=serverless-pi.mjs.map