@finalai/agent-definition 0.1.0

package/dist/compiler-assets/chunk-HNPUTP35.ts

@@ -0,0 +1,172 @@
+import {
+  DynamicEvent
+} from "./chunk-SKTNMUO7.ts";
+import {
+  array,
+  literal,
+  nativeEnum,
+  object,
+  string,
+  union
+} from "./chunk-HGW4YHAY.ts";
+
+// ../agent-provider/src/credentials.ts
+var CredentialPayer = /* @__PURE__ */ ((CredentialPayer2) => {
+  CredentialPayer2["AgentOwner"] = "agent-owner";
+  CredentialPayer2["Organization"] = "organization";
+  CredentialPayer2["PromptingUser"] = "prompting-user";
+  CredentialPayer2["ConversationOwner"] = "conversation-owner";
+  return CredentialPayer2;
+})(CredentialPayer || {});
+var CredentialOwner = /* @__PURE__ */ ((CredentialOwner2) => {
+  CredentialOwner2["Payer"] = "payer";
+  CredentialOwner2["Organization"] = "organization";
+  return CredentialOwner2;
+})(CredentialOwner || {});
+var InferenceCredentialKind = /* @__PURE__ */ ((InferenceCredentialKind2) => {
+  InferenceCredentialKind2["Subscription"] = "subscription";
+  InferenceCredentialKind2["ApiKey"] = "api-key";
+  InferenceCredentialKind2["Platform"] = "platform";
+  InferenceCredentialKind2["HarnessOwned"] = "harness-owned";
+  return InferenceCredentialKind2;
+})(InferenceCredentialKind || {});
+var CredentialDelivery = /* @__PURE__ */ ((CredentialDelivery2) => {
+  CredentialDelivery2["PerRequest"] = "per-request";
+  CredentialDelivery2["AtOpen"] = "at-open";
+  return CredentialDelivery2;
+})(CredentialDelivery || {});
+var subscriptionNodeSchema = object({
+  kind: literal("subscription" /* Subscription */),
+  owner: nativeEnum(CredentialOwner),
+  vendor: string().min(1).optional(),
+  pin: string().min(1).optional()
+});
+var apiKeyOwnerNodeSchema = object({
+  pin: string().min(1).optional(),
+  kind: literal("api-key" /* ApiKey */),
+  owner: nativeEnum(CredentialOwner),
+  vendor: string().min(1).optional()
+});
+var apiKeySecretNodeSchema = object({
+  kind: literal("api-key" /* ApiKey */),
+  secret: string().min(1),
+  baseUrl: string().url().optional(),
+  vendor: string().min(1).optional()
+});
+var platformNodeSchema = object({
+  kind: literal("platform" /* Platform */),
+  budget: string().min(1).optional()
+});
+var harnessNodeSchema = object({
+  kind: literal("harness-owned" /* HarnessOwned */)
+});
+var customNodeSchema = object({
+  kind: literal("custom" /* Custom */),
+  // Bundle export of a defineDynamic resolver returning one of the other nodes,
+  // or `{ kind: 'api-key', value }` held in memory by the broker.
+  resolver: string().min(1),
+  events: array(nativeEnum(DynamicEvent)).default(["session.started" /* SessionStarted */])
+});
+var credentialNodeSchema = union([
+  subscriptionNodeSchema,
+  apiKeySecretNodeSchema,
+  apiKeyOwnerNodeSchema,
+  platformNodeSchema,
+  harnessNodeSchema,
+  customNodeSchema
+]);
+var credentialPolicySchema = object({
+  payer: nativeEnum(CredentialPayer),
+  tryInOrder: array(credentialNodeSchema).min(1)
+});
+var customResolverResultSchema = union([
+  credentialNodeSchema,
+  object({
+    kind: literal("api-key" /* ApiKey */),
+    value: string().min(1),
+    vendor: string().min(1).optional(),
+    baseUrl: string().url().optional()
+  })
+]);
+var ownerSchema = nativeEnum(CredentialOwner);
+var toOwner = (owner) => ownerSchema.parse(owner);
+var payerSchema = nativeEnum(CredentialPayer);
+var toPayer = (payer) => payerSchema.parse(payer);
+var credentials = {
+  chain: (args) => credentialPolicySchema.parse({ payer: toPayer(args.payer), tryInOrder: args.tryInOrder }),
+  subscription: (args) => {
+    const node = {
+      kind: "subscription" /* Subscription */,
+      owner: toOwner(args.owner)
+    };
+    if (args.vendor != null) node.vendor = args.vendor;
+    if (args.pin != null) node.pin = args.pin;
+    return node;
+  },
+  apiKey: (args) => {
+    if ("secret" in args) {
+      const node2 = { kind: "api-key" /* ApiKey */, secret: args.secret };
+      if (args.baseUrl != null) node2.baseUrl = args.baseUrl;
+      if (args.vendor != null) node2.vendor = args.vendor;
+      return node2;
+    }
+    const node = {
+      kind: "api-key" /* ApiKey */,
+      owner: toOwner(args.owner)
+    };
+    if (args.vendor != null) node.vendor = args.vendor;
+    if (args.pin != null) node.pin = args.pin;
+    return node;
+  },
+  platform: (args) => {
+    const node = { kind: "platform" /* Platform */ };
+    if (args?.budget != null) node.budget = args.budget;
+    return node;
+  },
+  harness: () => ({ kind: "harness-owned" /* HarnessOwned */ }),
+  custom: (ref) => ({
+    kind: "custom" /* Custom */,
+    resolver: ref.resolverExport,
+    events: ref.events ?? ["session.started" /* SessionStarted */]
+  })
+};
+var defaultPersonalCredentialPolicy = () => credentials.chain({
+  payer: "agent-owner" /* AgentOwner */,
+  tryInOrder: [
+    credentials.subscription({ owner: "payer" /* Payer */ }),
+    credentials.platform()
+  ]
+});
+var defaultOrganizationCredentialPolicy = () => credentials.chain({
+  payer: "organization" /* Organization */,
+  tryInOrder: [
+    credentials.subscription({ owner: "organization" /* Organization */ }),
+    credentials.platform()
+  ]
+});
+var inferenceKindOfNode = (node) => {
+  switch (node.kind) {
+    case "subscription" /* Subscription */:
+      return "subscription" /* Subscription */;
+    case "api-key" /* ApiKey */:
+      return "api-key" /* ApiKey */;
+    case "platform" /* Platform */:
+      return "platform" /* Platform */;
+    case "harness-owned" /* HarnessOwned */:
+      return "harness-owned" /* HarnessOwned */;
+    case "custom" /* Custom */:
+      return null;
+  }
+};
+
+export {
+  CredentialPayer,
+  CredentialOwner,
+  InferenceCredentialKind,
+  CredentialDelivery,
+  credentialPolicySchema,
+  credentials,
+  defaultPersonalCredentialPolicy,
+  defaultOrganizationCredentialPolicy,
+  inferenceKindOfNode
+};

package/dist/compiler-assets/chunk-JIPNTA56.ts

@@ -0,0 +1,59 @@
+import {
+  _function,
+  boolean,
+  custom,
+  looseObject,
+  number,
+  record,
+  string,
+  unknown
+} from "./chunk-HGW4YHAY.ts";
+
+// src/runtime/values.ts
+var authoredValueSchema = unknown();
+var optionalValueSchema = authoredValueSchema.optional();
+var functionSchema = _function();
+var callableSchema = custom(
+  (value) => functionSchema.safeParse(value).success
+);
+var authoredRecordSchema = record(string(), authoredValueSchema);
+var isCallable = (value) => callableSchema.safeParse(value).success;
+var isString = (value) => string().safeParse(value).success;
+var isNumber = (value) => number().safeParse(value).success;
+var isBoolean = (value) => boolean().safeParse(value).success;
+var stringOrNull = (value) => isString(value) ? value : null;
+var isObjectLike = (value) => value instanceof Object;
+var isPlainObject = (value) => {
+  if (!isObjectLike(value) || Array.isArray(value) || isCallable(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto == null || Object.getPrototypeOf(proto) == null;
+};
+var fieldOf = (value, key) => {
+  if (!isObjectLike(value) || !(key in value)) return void 0;
+  const parsed = looseObject({ [key]: optionalValueSchema }).safeParse(value);
+  if (parsed.success) return parsed.data[key];
+  return Object.getOwnPropertyDescriptor(value, key)?.value;
+};
+var entriesOf = (value) => isObjectLike(value) ? Object.entries(value) : [];
+var isPromiseLike = (value) => isCallable(fieldOf(value, "then"));
+var isAsyncIterable = (value) => isObjectLike(value) && Symbol.asyncIterator in value;
+var messageOf = (cause) => cause instanceof Error ? cause.message : String(cause);
+
+export {
+  authoredValueSchema,
+  optionalValueSchema,
+  callableSchema,
+  authoredRecordSchema,
+  isCallable,
+  isString,
+  isNumber,
+  isBoolean,
+  stringOrNull,
+  isObjectLike,
+  isPlainObject,
+  fieldOf,
+  entriesOf,
+  isPromiseLike,
+  isAsyncIterable,
+  messageOf
+};

package/dist/compiler-assets/chunk-JNJE72EH.ts

@@ -0,0 +1,10 @@
+import {
+  stamp
+} from "./chunk-XHKPWT3G.ts";
+
+// src/authoring/connections.ts
+var defineMcpClientConnection = (definition) => stamp({ ...definition }, "connection" /* Connection */);
+
+export {
+  defineMcpClientConnection
+};

package/dist/compiler-assets/chunk-JPY4L2UJ.ts

@@ -0,0 +1,349 @@
+import {
+  BaseCapability,
+  providerRefSchema
+} from "./chunk-OWC6SFFF.ts";
+import {
+  jsonObjectSchema,
+  jsonSchemaSchema
+} from "./chunk-7QP2CKPI.ts";
+import {
+  CredentialDelivery,
+  InferenceCredentialKind
+} from "./chunk-HNPUTP35.ts";
+import {
+  array,
+  boolean,
+  json,
+  literal,
+  nativeEnum,
+  number,
+  object,
+  partialRecord,
+  record,
+  string,
+  union
+} from "./chunk-HGW4YHAY.ts";
+
+// ../agent-provider/src/schemas.ts
+var SCHEMA_IDS = {
+  modelPicker: "final://schemas/model-picker",
+  credentialPolicy: "final://schemas/credential-policy",
+  permissionMode: "final://schemas/permission-mode",
+  instructions: "final://schemas/instructions",
+  skills: "final://schemas/skills",
+  reasoning: "final://schemas/reasoning",
+  secretRef: "final://schemas/secret-ref"
+};
+var dynamicSlotJsonSchema = {
+  type: "object",
+  required: ["$dynamic"],
+  properties: {
+    $dynamic: {
+      type: "object",
+      required: ["resolver", "events"],
+      properties: {
+        resolver: { type: "string" },
+        events: { type: "array", items: { enum: ["session.started", "turn.started"] } },
+        description: { type: "string" },
+        preview: { type: "string" }
+      }
+    }
+  }
+};
+var credentialNodeJsonSchema = {
+  type: "object",
+  required: ["kind"],
+  properties: {
+    kind: { enum: ["subscription", "api-key", "platform", "harness-owned", "custom"] },
+    owner: { enum: ["payer", "organization"] },
+    vendor: { type: "string" },
+    pin: { type: "string" },
+    secret: { type: "string" },
+    baseUrl: { type: "string", format: "uri" },
+    budget: { type: "string" },
+    resolver: { type: "string" }
+  }
+};
+var SHARED_SCHEMAS = {
+  [SCHEMA_IDS.modelPicker]: {
+    $id: SCHEMA_IDS.modelPicker,
+    title: "Model",
+    // The harness supplies the enum: { $ref: model-picker, enum: [...] }.
+    type: "string",
+    "x-final-widget": "model-picker"
+  },
+  [SCHEMA_IDS.reasoning]: {
+    $id: SCHEMA_IDS.reasoning,
+    title: "Reasoning",
+    enum: ["none", "minimal", "low", "medium", "high", "max"],
+    "x-final-widget": "reasoning-picker"
+  },
+  [SCHEMA_IDS.credentialPolicy]: {
+    $id: SCHEMA_IDS.credentialPolicy,
+    title: "Credentials",
+    type: "object",
+    required: ["payer", "tryInOrder"],
+    properties: {
+      payer: { enum: ["agent-owner", "organization", "prompting-user", "conversation-owner"] },
+      tryInOrder: { type: "array", minItems: 1, items: credentialNodeJsonSchema }
+    },
+    "x-final-widget": "credential-policy"
+  },
+  [SCHEMA_IDS.permissionMode]: {
+    $id: SCHEMA_IDS.permissionMode,
+    title: "Permission mode",
+    // The harness supplies the enum of its own modes.
+    type: "string",
+    "x-final-widget": "permission-mode"
+  },
+  [SCHEMA_IDS.instructions]: {
+    $id: SCHEMA_IDS.instructions,
+    title: "Instructions",
+    type: "array",
+    items: {
+      anyOf: [
+        {
+          type: "object",
+          required: ["role", "content"],
+          properties: {
+            role: { enum: ["system", "user"] },
+            content: { type: "string" },
+            source: { type: "string" }
+          }
+        },
+        dynamicSlotJsonSchema
+      ]
+    },
+    "x-final-widget": "instructions"
+  },
+  [SCHEMA_IDS.skills]: {
+    $id: SCHEMA_IDS.skills,
+    title: "Skills",
+    type: "array",
+    items: {
+      anyOf: [
+        {
+          type: "object",
+          required: ["key", "files"],
+          properties: {
+            key: { type: "string" },
+            description: { type: "string" },
+            files: {
+              type: "array",
+              items: {
+                type: "object",
+                required: ["path", "content"],
+                properties: { path: { type: "string" }, content: { type: "string" } }
+              }
+            }
+          }
+        },
+        dynamicSlotJsonSchema
+      ]
+    },
+    "x-final-widget": "skills"
+  },
+  [SCHEMA_IDS.secretRef]: {
+    $id: SCHEMA_IDS.secretRef,
+    title: "Secret",
+    type: "object",
+    required: ["secretKey"],
+    properties: { secretKey: { type: "string" } },
+    "x-final-widget": "secret-picker"
+  }
+};
+var fieldRefSchema = object({ $ref: string().startsWith("final://schemas/") });
+var propertiesSchema = object({ properties: record(string(), json()) });
+var referencedSharedSchemas = (configSchema) => {
+  const parsed = propertiesSchema.safeParse(configSchema);
+  const out = {};
+  if (!parsed.success) return out;
+  for (const [field, fieldSchema] of Object.entries(parsed.data.properties)) {
+    const ref = fieldRefSchema.safeParse(fieldSchema);
+    if (ref.success) out[field] = ref.data.$ref;
+  }
+  return out;
+};
+
+// ../agent-provider/src/credential-routes.ts
+var CredentialRoute = /* @__PURE__ */ ((CredentialRoute2) => {
+  CredentialRoute2["Model"] = "model";
+  CredentialRoute2["Mcp"] = "mcp";
+  CredentialRoute2["Sandbox"] = "sandbox";
+  CredentialRoute2["TranscriptStore"] = "transcript-store";
+  CredentialRoute2["SubscriptionRelay"] = "subscription-relay";
+  CredentialRoute2["FinalMcp"] = "final-mcp";
+  return CredentialRoute2;
+})(CredentialRoute || {});
+var routeGrantSchema = object({
+  route: nativeEnum(CredentialRoute),
+  token: string().min(1),
+  expiresAt: string()
+});
+var credentialRefreshRequestSchema = object({
+  harnessSessionId: string().uuid(),
+  routes: array(nativeEnum(CredentialRoute)).min(1).max(8)
+});
+
+// ../agent-provider/src/harness.ts
+var AcpTransport = /* @__PURE__ */ ((AcpTransport2) => {
+  AcpTransport2["Relay"] = "relay";
+  AcpTransport2["Ws"] = "ws";
+  AcpTransport2["Http"] = "http";
+  AcpTransport2["Stdio"] = "stdio";
+  return AcpTransport2;
+})(AcpTransport || {});
+var McpTransportKind = /* @__PURE__ */ ((McpTransportKind2) => {
+  McpTransportKind2["Acp"] = "acp";
+  McpTransportKind2["Http"] = "http";
+  McpTransportKind2["Stdio"] = "stdio";
+  return McpTransportKind2;
+})(McpTransportKind || {});
+var BaseToolProvision = /* @__PURE__ */ ((BaseToolProvision2) => {
+  BaseToolProvision2["Bound"] = "bound";
+  BaseToolProvision2["HostDisableable"] = "host-disableable";
+  BaseToolProvision2["HostFixed"] = "host-fixed";
+  return BaseToolProvision2;
+})(BaseToolProvision || {});
+var SandboxWire = /* @__PURE__ */ ((SandboxWire2) => {
+  SandboxWire2["HandleRpc"] = "handle-rpc";
+  SandboxWire2["Mcp"] = "mcp";
+  return SandboxWire2;
+})(SandboxWire || {});
+var UserInstructionDelivery = /* @__PURE__ */ ((UserInstructionDelivery2) => {
+  UserInstructionDelivery2["History"] = "history";
+  UserInstructionDelivery2["System"] = "system";
+  return UserInstructionDelivery2;
+})(UserInstructionDelivery || {});
+var HarnessTrustClass = /* @__PURE__ */ ((HarnessTrustClass2) => {
+  HarnessTrustClass2["FirstParty"] = "first-party";
+  HarnessTrustClass2["ThirdParty"] = "third-party";
+  return HarnessTrustClass2;
+})(HarnessTrustClass || {});
+var PromptWhileRunning = /* @__PURE__ */ ((PromptWhileRunning2) => {
+  PromptWhileRunning2["Inject"] = "inject";
+  PromptWhileRunning2["Queue"] = "queue";
+  return PromptWhileRunning2;
+})(PromptWhileRunning || {});
+var DEFAULT_PROMPT_WHILE_RUNNING = "queue" /* Queue */;
+var DEFAULT_SESSION_SURVIVES_DISCONNECT = false;
+var baseToolDeclarationSchema = object({
+  provision: nativeEnum(BaseToolProvision),
+  nativeTools: array(string())
+});
+var harnessDescriptionSchema = object({
+  // Everything configurable about this harness (model, reasoning, credentials,
+  // permission mode, instructions, skills, cwd, ...). JSON Schema so Build can
+  // render it; may $ref the shared final://schemas/* fragments.
+  configSchema: jsonSchemaSchema,
+  // Absent: user fragments enter history. System-only programs declare their conversion.
+  userInstructionDelivery: nativeEnum(UserInstructionDelivery).optional(),
+  acp: object({
+    transports: array(nativeEnum(AcpTransport)).min(1),
+    mcp: array(nativeEnum(McpTransportKind))
+  }),
+  // A capability missing here is unavailable on this harness.
+  baseTools: partialRecord(nativeEnum(BaseCapability), baseToolDeclarationSchema),
+  consumes: array(nativeEnum(SandboxWire)),
+  inference: object({
+    vendors: array(string()),
+    kinds: array(nativeEnum(InferenceCredentialKind)),
+    delivery: nativeEnum(CredentialDelivery)
+  }),
+  // Absent: third-party.
+  trust: nativeEnum(HarnessTrustClass).optional(),
+  supports: object({
+    observe: boolean(),
+    resumeReplay: boolean(),
+    fork: boolean(),
+    // Renders _meta["final.ai"].author itself; otherwise the channel prepends
+    // the author's name to the text.
+    authorMeta: boolean(),
+    // Explicit false: native toolPolicy cannot be enforced by this adapter's public surface.
+    nativeToolPolicy: boolean().optional()
+  }),
+  promptWhileRunning: nativeEnum(PromptWhileRunning).default(DEFAULT_PROMPT_WHILE_RUNNING),
+  // Keeps the session, its running work and its open requests across a dropped
+  // connection, buffers updates for replay, and re-raises the open requests
+  // with the same JSON-RPC ids on the next session/resume. False:
+  // open turns end `harness_state_lost` after a reconnect.
+  sessionSurvivesDisconnect: boolean().default(DEFAULT_SESSION_SURVIVES_DISCONNECT)
+});
+var deliveredHarnessConfig = (args) => {
+  if (args.description.userInstructionDelivery !== "system" /* System */)
+    return args.config;
+  const config = jsonObjectSchema.safeParse(args.config);
+  if (!config.success) return args.config;
+  const fields = referencedSharedSchemas(args.description.configSchema);
+  const field = Object.entries(fields).find(([, schema]) => schema === SCHEMA_IDS.instructions)?.[0] ?? "instructions";
+  const instructions = config.data[field];
+  if (!Array.isArray(instructions)) return args.config;
+  return {
+    ...config.data,
+    [field]: instructions.map((value) => {
+      const fragment = jsonObjectSchema.safeParse(value);
+      return fragment.success && fragment.data["role"] === "user" /* User */ ? { ...fragment.data, role: "system" /* System */ } : value;
+    })
+  };
+};
+var harnessSessionRefSchema = object({
+  harness: providerRefSchema,
+  // Opaque to the session service; the harness's own id for the session.
+  harnessSessionRef: string().min(1),
+  // Bumped whenever the harness loses state; a mismatch on resume means the
+  // session service must re-seed with session/new.
+  generation: number().int().nonnegative()
+});
+var atOpenModelCredentialSchema = object({
+  vendor: string(),
+  kind: nativeEnum(InferenceCredentialKind),
+  baseUrl: string().min(1).nullable(),
+  apiKey: string().min(1).nullable(),
+  subscription: object({
+    format: union([literal("claude-setup-token"), literal("chatgpt-auth-tokens")]),
+    value: string().min(1)
+  }).nullable(),
+  fingerprint: string()
+});
+var credentialGrantRefreshSchema = object({
+  url: string().min(1),
+  token: string().min(1),
+  harnessSessionId: string().min(1),
+  expiresAt: string()
+});
+var credentialGrantSchema = object({
+  brokerUrl: string().min(1),
+  grants: array(routeGrantSchema),
+  atOpen: atOpenModelCredentialSchema.nullable(),
+  refresh: credentialGrantRefreshSchema.nullable()
+});
+var endpointTokenSchema = object({
+  url: string().min(1),
+  token: string(),
+  expiresAt: string()
+});
+var sandboxTargetEndpointSchema = object({
+  target: string().min(1),
+  bindingId: string().min(1),
+  capabilities: array(string()),
+  rpc: endpointTokenSchema.nullable(),
+  mcp: endpointTokenSchema.nullable()
+});
+var renewedMcpServerSchema = object({
+  name: string().min(1),
+  url: string().min(1),
+  headers: array(object({ name: string().min(1), value: string() }))
+});
+var credentialRefreshResultSchema = credentialGrantSchema.extend({
+  mcpServers: array(renewedMcpServerSchema).default([]),
+  sandboxes: record(string(), sandboxTargetEndpointSchema).default({})
+});
+
+export {
+  SCHEMA_IDS,
+  SHARED_SCHEMAS,
+  referencedSharedSchemas,
+  SandboxWire,
+  harnessDescriptionSchema,
+  deliveredHarnessConfig
+};

package/dist/compiler-assets/chunk-LUSAAV4L.ts

@@ -0,0 +1,33 @@
+import {
+  awaitableOpenRequest
+} from "./chunk-CWWRTRWW.ts";
+import {
+  stamp
+} from "./chunk-XHKPWT3G.ts";
+
+// ../agent-provider/src/sandbox/types.ts
+var defineSandboxProvider = (definition) => ({
+  definition,
+  name: definition.name,
+  environment: (options) => ({
+    providerName: definition.name,
+    options,
+    open: (openOptions) => awaitableOpenRequest({
+      providerName: definition.name,
+      environmentOptions: options,
+      openOptions
+    })
+  })
+});
+
+// src/authoring/sandbox.ts
+var harnessHost = stamp({ harnessHost: true }, "harness-host" /* HarnessHost */);
+var defineSandbox = (value) => value instanceof Function ? stamp(value, "sandbox-selector" /* SandboxSelector */) : value;
+var baseTools = (base) => stamp({ base: { ...base } }, "base-tools" /* BaseTools */);
+
+export {
+  defineSandboxProvider,
+  harnessHost,
+  defineSandbox,
+  baseTools
+};