@finalai/agent-definition 0.1.0

package/dist/compiler-assets/src/runtime/schema-validation.ts

@@ -0,0 +1,21 @@
+import {
+  SchemaIo,
+  jsonSchemaDeclarationError,
+  jsonSchemaError,
+  resultMatchesSchema,
+  standardValidatorSchema,
+  validateSchemaValue
+} from "../../chunk-GNR7XBPN.ts";
+import "../../chunk-7WGYG73V.ts";
+import "../../chunk-7QP2CKPI.ts";
+import "../../chunk-JIPNTA56.ts";
+import "../../chunk-HGW4YHAY.ts";
+import "../../chunk-32O3ODZE.ts";
+export {
+  SchemaIo,
+  jsonSchemaDeclarationError,
+  jsonSchemaError,
+  resultMatchesSchema,
+  standardValidatorSchema,
+  validateSchemaValue
+};

package/dist/compiler-assets/src/runtime/values.ts

@@ -0,0 +1,38 @@
+import {
+  authoredRecordSchema,
+  authoredValueSchema,
+  callableSchema,
+  entriesOf,
+  fieldOf,
+  isAsyncIterable,
+  isBoolean,
+  isCallable,
+  isNumber,
+  isObjectLike,
+  isPlainObject,
+  isPromiseLike,
+  isString,
+  messageOf,
+  optionalValueSchema,
+  stringOrNull
+} from "../../chunk-JIPNTA56.ts";
+import "../../chunk-HGW4YHAY.ts";
+import "../../chunk-32O3ODZE.ts";
+export {
+  authoredRecordSchema,
+  authoredValueSchema,
+  callableSchema,
+  entriesOf,
+  fieldOf,
+  isAsyncIterable,
+  isBoolean,
+  isCallable,
+  isNumber,
+  isObjectLike,
+  isPlainObject,
+  isPromiseLike,
+  isString,
+  messageOf,
+  optionalValueSchema,
+  stringOrNull
+};

package/dist/modules/authoring/agent.d.mts

@@ -0,0 +1,22 @@
+import type { JsonObject, ProviderRef, ToolApproval } from '@finalai/agent-provider';
+import type { BaseToolsValueIface } from "./sandbox.mjs";
+export interface HarnessBindingValueIface {
+    readonly harness: ProviderRef;
+    readonly config: unknown;
+}
+export interface ChannelBindingValueIface {
+    readonly channel: ProviderRef;
+    readonly config?: JsonObject;
+    readonly key?: string;
+}
+export interface AgentDefinitionInputIface {
+    readonly name?: string;
+    readonly description?: string;
+    readonly avatarUrl?: string;
+    readonly harness: HarnessBindingValueIface;
+    readonly tools?: BaseToolsValueIface;
+    readonly toolPolicy?: Readonly<Record<string, ToolApproval | `${ToolApproval}`>>;
+    readonly secrets?: readonly string[];
+    readonly channels?: readonly ChannelBindingValueIface[];
+}
+export declare const defineAgent: <TAgent extends AgentDefinitionInputIface>(definition: TAgent) => TAgent;

package/dist/modules/authoring/agent.mjs

@@ -0,0 +1,6 @@
+import { AuthoredKind, stamp } from "./brand.mjs";
+const defineAgent = (definition) => stamp({ ...definition }, AuthoredKind.Agent);
+export {
+  defineAgent
+};
+//# sourceMappingURL=agent.mjs.map

package/dist/modules/authoring/agent.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/authoring/agent.ts"],
+  "sourcesContent": ["import type { JsonObject, ProviderRef, ToolApproval } from '@finalai/agent-provider';\nimport { AuthoredKind, stamp } from \"./brand.mjs\";\nimport type { BaseToolsValueIface } from \"./sandbox.mjs\";\n\n// A harness binding as authoring helpers produce it: an installed harness\n// helper (`serverlessPi({...})`), a defineHarness result, or a literal.\nexport interface HarnessBindingValueIface {\n  readonly harness: ProviderRef;\n  readonly config: unknown;\n}\n\nexport interface ChannelBindingValueIface {\n  readonly channel: ProviderRef;\n  readonly config?: JsonObject;\n  readonly key?: string;\n}\n\n// agent.ts. The agent names its harness; everything\n// the harness has an opinion about (model, reasoning, credentials, permission\n// mode, instructions, skills) lives in `harness.config`.\nexport interface AgentDefinitionInputIface {\n  readonly name?: string;\n  readonly description?: string;\n  readonly avatarUrl?: string;\n  readonly harness: HarnessBindingValueIface;\n  // Base tool capabilities bound to sandbox targets; none unless declared.\n  readonly tools?: BaseToolsValueIface;\n  // Extra approval policy for MCP tools (`<server>/<tool>`) and base\n  // capabilities (`shell`, `files.write`).\n  readonly toolPolicy?: Readonly<Record<string, ToolApproval | `${ToolApproval}`>>;\n  // Organization secrets this agent's code may read with `ctx.secrets.get(name)`\n  // (tools, hooks, resolvers, channel routes). Names referenced elsewhere in the\n  // definition (connection `auth.secretKey`, `credentials.apiKey({ secret })`)\n  // are added by the compiler; any other secret must be listed here, or reading\n  // it fails at run time.\n  readonly secrets?: readonly string[];\n  // Installed channels (custom channels are files under channels/).\n  readonly channels?: readonly ChannelBindingValueIface[];\n}\n\nexport const defineAgent = <TAgent extends AgentDefinitionInputIface>(definition: TAgent): TAgent =>\n  stamp({ ...definition }, AuthoredKind.Agent);\n"],
+  "mappings": "AACA,SAAS,cAAc,aAAa;AAuC7B,MAAM,cAAc,CAA2C,eACpE,MAAM,EAAE,GAAG,WAAW,GAAG,aAAa,KAAK;",
+  "names": []
+}

package/dist/modules/authoring/approval.d.mts

@@ -0,0 +1,17 @@
+import { ToolApproval } from '@finalai/agent-provider';
+import { type AuthoredValue } from "../runtime/values.mjs";
+export interface ApprovalPolicyIface<TInput = unknown> {
+    readonly policy: ToolApproval;
+    readonly note: string | null;
+    readonly predicate?: (input: Readonly<TInput>) => boolean;
+}
+export declare const always: <TInput = unknown>() => ApprovalPolicyIface<TInput>;
+export declare const never: <TInput = unknown>() => ApprovalPolicyIface<TInput>;
+export declare const whenInput: <TInput = unknown>(predicate: (input: Readonly<TInput>) => boolean) => ApprovalPolicyIface<TInput>;
+export interface LoweredApprovalIface {
+    policy: ToolApproval;
+    note: string | null;
+    error: string | null;
+    inputDependent: boolean;
+}
+export declare const lowerApproval: (value: AuthoredValue) => LoweredApprovalIface;

package/dist/modules/authoring/approval.mjs

@@ -0,0 +1,42 @@
+import { ToolApproval } from "@finalai/agent-provider";
+import * as z from "zod";
+import { callableSchema } from "../runtime/values.mjs";
+import { AuthoredKind, authoredKindOf, stamp } from "./brand.mjs";
+const policy = (value, note = null) => stamp({ policy: value, note }, AuthoredKind.Approval);
+const always = () => policy(ToolApproval.Ask);
+const never = () => policy(ToolApproval.Allow);
+const whenInput = (predicate) => stamp({ policy: ToolApproval.Ask, note: null, predicate }, AuthoredKind.Approval);
+const approvalSchema = z.object({
+  policy: z.nativeEnum(ToolApproval),
+  note: z.string().nullable(),
+  predicate: callableSchema.optional()
+});
+const lowerApproval = (value) => {
+  if (value == null)
+    return { policy: ToolApproval.Allow, note: null, error: null, inputDependent: false };
+  const parsed = approvalSchema.safeParse(value);
+  if (authoredKindOf(value) === AuthoredKind.Approval && parsed.success) {
+    return {
+      policy: parsed.data.policy,
+      note: parsed.data.note,
+      error: null,
+      inputDependent: parsed.data.predicate != null
+    };
+  }
+  if (value === ToolApproval.Ask || value === ToolApproval.Allow) {
+    return { policy: value, note: null, error: null, inputDependent: false };
+  }
+  return {
+    policy: ToolApproval.Ask,
+    note: null,
+    inputDependent: false,
+    error: "approval callbacks are not supported; use always(), never() or whenInput() from @finalai/agents/approval"
+  };
+};
+export {
+  always,
+  lowerApproval,
+  never,
+  whenInput
+};
+//# sourceMappingURL=approval.mjs.map

package/dist/modules/authoring/approval.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/authoring/approval.ts"],
+  "sourcesContent": ["import { ToolApproval } from '@finalai/agent-provider';\nimport * as z from 'zod';\nimport { callableSchema, type AuthoredValue } from \"../runtime/values.mjs\";\nimport { AuthoredKind, authoredKindOf, stamp } from \"./brand.mjs\";\n\n// Approval helpers. They compile to the manifest's\n// 'allow' | 'ask'; the MCP host enforces 'ask' by raising MCP elicitation.\n// Input predicates run in the pinned bundle isolate before the host asks.\n\nexport interface ApprovalPolicyIface<TInput = unknown> {\n  readonly policy: ToolApproval;\n  // Why a richer policy was lowered to 'ask'; surfaced as a compiler note.\n  readonly note: string | null;\n  readonly predicate?: (input: Readonly<TInput>) => boolean;\n}\n\nconst policy = <TInput>(\n  value: ToolApproval,\n  note: string | null = null,\n): ApprovalPolicyIface<TInput> => stamp({ policy: value, note }, AuthoredKind.Approval);\n\nexport const always = <TInput = unknown>(): ApprovalPolicyIface<TInput> => policy(ToolApproval.Ask);\n\nexport const never = <TInput = unknown>(): ApprovalPolicyIface<TInput> =>\n  policy(ToolApproval.Allow);\n\nexport const whenInput = <TInput = unknown>(\n  predicate: (input: Readonly<TInput>) => boolean,\n): ApprovalPolicyIface<TInput> =>\n  stamp({ policy: ToolApproval.Ask, note: null, predicate }, AuthoredKind.Approval);\n\nexport interface LoweredApprovalIface {\n  policy: ToolApproval;\n  note: string | null;\n  error: string | null;\n  inputDependent: boolean;\n}\n\nconst approvalSchema = z.object({\n  policy: z.nativeEnum(ToolApproval),\n  note: z.string().nullable(),\n  predicate: callableSchema.optional(),\n});\n\nexport const lowerApproval = (value: AuthoredValue): LoweredApprovalIface => {\n  if (value == null)\n    return { policy: ToolApproval.Allow, note: null, error: null, inputDependent: false };\n  const parsed = approvalSchema.safeParse(value);\n  if (authoredKindOf(value) === AuthoredKind.Approval && parsed.success) {\n    return {\n      policy: parsed.data.policy,\n      note: parsed.data.note,\n      error: null,\n      inputDependent: parsed.data.predicate != null,\n    };\n  }\n  if (value === ToolApproval.Ask || value === ToolApproval.Allow) {\n    return { policy: value, note: null, error: null, inputDependent: false };\n  }\n  return {\n    policy: ToolApproval.Ask,\n    note: null,\n    inputDependent: false,\n    error:\n      'approval callbacks are not supported; use always(), never() or whenInput() from @finalai/agents/approval',\n  };\n};\n"],
+  "mappings": "AAAA,SAAS,oBAAoB;AAC7B,YAAY,OAAO;AACnB,SAAS,sBAA0C;AACnD,SAAS,cAAc,gBAAgB,aAAa;AAapD,MAAM,SAAS,CACb,OACA,OAAsB,SACU,MAAM,EAAE,QAAQ,OAAO,KAAK,GAAG,aAAa,QAAQ;AAE/E,MAAM,SAAS,MAAqD,OAAO,aAAa,GAAG;AAE3F,MAAM,QAAQ,MACnB,OAAO,aAAa,KAAK;AAEpB,MAAM,YAAY,CACvB,cAEA,MAAM,EAAE,QAAQ,aAAa,KAAK,MAAM,MAAM,UAAU,GAAG,aAAa,QAAQ;AASlF,MAAM,iBAAiB,EAAE,OAAO;AAAA,EAC9B,QAAQ,EAAE,WAAW,YAAY;AAAA,EACjC,MAAM,EAAE,OAAO,EAAE,SAAS;AAAA,EAC1B,WAAW,eAAe,SAAS;AACrC,CAAC;AAEM,MAAM,gBAAgB,CAAC,UAA+C;AAC3E,MAAI,SAAS;AACX,WAAO,EAAE,QAAQ,aAAa,OAAO,MAAM,MAAM,OAAO,MAAM,gBAAgB,MAAM;AACtF,QAAM,SAAS,eAAe,UAAU,KAAK;AAC7C,MAAI,eAAe,KAAK,MAAM,aAAa,YAAY,OAAO,SAAS;AACrE,WAAO;AAAA,MACL,QAAQ,OAAO,KAAK;AAAA,MACpB,MAAM,OAAO,KAAK;AAAA,MAClB,OAAO;AAAA,MACP,gBAAgB,OAAO,KAAK,aAAa;AAAA,IAC3C;AAAA,EACF;AACA,MAAI,UAAU,aAAa,OAAO,UAAU,aAAa,OAAO;AAC9D,WAAO,EAAE,QAAQ,OAAO,MAAM,MAAM,OAAO,MAAM,gBAAgB,MAAM;AAAA,EACzE;AACA,SAAO;AAAA,IACL,QAAQ,aAAa;AAAA,IACrB,MAAM;AAAA,IACN,gBAAgB;AAAA,IAChB,OACE;AAAA,EACJ;AACF;",
+  "names": []
+}

package/dist/modules/authoring/brand.d.mts

@@ -0,0 +1,27 @@
+import { type AuthoredValue } from "../runtime/values.mjs";
+export declare enum AuthoredKind {
+    Agent = "agent",
+    Tool = "tool",
+    Dynamic = "dynamic",
+    Instructions = "instructions",
+    Skill = "skill",
+    Connection = "connection",
+    Schedule = "schedule",
+    SandboxSelector = "sandbox-selector",
+    BaseTools = "base-tools",
+    HarnessHost = "harness-host",
+    Hook = "hook",
+    Channel = "channel",
+    Approval = "approval"
+}
+export declare const stamp: <T extends object>(value: T, kind: AuthoredKind) => T;
+export declare const authoredKindOf: (value: AuthoredValue) => AuthoredKind | null;
+export declare const isAuthored: (value: AuthoredValue, kind: AuthoredKind) => boolean;
+export declare const registerPending: (value: AuthoredValue) => string;
+export declare const pendingEntries: () => {
+    placeholder: string;
+    index: number;
+    value: AuthoredValue;
+}[];
+export declare const pendingIndexOf: (placeholder: string) => number | null;
+export declare const pendingExportName: (index: number) => string;

package/dist/modules/authoring/brand.mjs

@@ -0,0 +1,51 @@
+import { isObjectLike } from "../runtime/values.mjs";
+var AuthoredKind = /* @__PURE__ */ ((AuthoredKind2) => {
+  AuthoredKind2["Agent"] = "agent";
+  AuthoredKind2["Tool"] = "tool";
+  AuthoredKind2["Dynamic"] = "dynamic";
+  AuthoredKind2["Instructions"] = "instructions";
+  AuthoredKind2["Skill"] = "skill";
+  AuthoredKind2["Connection"] = "connection";
+  AuthoredKind2["Schedule"] = "schedule";
+  AuthoredKind2["SandboxSelector"] = "sandbox-selector";
+  AuthoredKind2["BaseTools"] = "base-tools";
+  AuthoredKind2["HarnessHost"] = "harness-host";
+  AuthoredKind2["Hook"] = "hook";
+  AuthoredKind2["Channel"] = "channel";
+  AuthoredKind2["Approval"] = "approval";
+  return AuthoredKind2;
+})(AuthoredKind || {});
+const kinds = /* @__PURE__ */ new WeakMap();
+const stamp = (value, kind) => {
+  kinds.set(value, kind);
+  return value;
+};
+const authoredKindOf = (value) => isObjectLike(value) ? kinds.get(value) ?? null : null;
+const isAuthored = (value, kind) => authoredKindOf(value) === kind;
+const PENDING_PREFIX = "<pending:";
+const pendingValues = [];
+const registerPending = (value) => {
+  pendingValues.push(value);
+  return `${PENDING_PREFIX}${pendingValues.length - 1}>`;
+};
+const pendingEntries = () => pendingValues.map((value, index) => ({
+  placeholder: `${PENDING_PREFIX}${index}>`,
+  index,
+  value
+}));
+const pendingIndexOf = (placeholder) => {
+  const match = /^<pending:(\d+)>$/.exec(placeholder);
+  return match?.[1] == null ? null : Number(match[1]);
+};
+const pendingExportName = (index) => `pending:${index}`;
+export {
+  AuthoredKind,
+  authoredKindOf,
+  isAuthored,
+  pendingEntries,
+  pendingExportName,
+  pendingIndexOf,
+  registerPending,
+  stamp
+};
+//# sourceMappingURL=brand.mjs.map

package/dist/modules/authoring/brand.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/authoring/brand.ts"],
+  "sourcesContent": ["import { isObjectLike, type AuthoredValue } from \"../runtime/values.mjs\";\n\n// Authored values are plain objects (or functions) registered with their\n// kind, so the compiler's evaluation realm and the isolate runtime recognize\n// them without classes or instanceof. The registry lives in the same realm as\n// the authored code, because the authoring module is bundled with it.\n\nexport enum AuthoredKind {\n  Agent = 'agent',\n  Tool = 'tool',\n  Dynamic = 'dynamic',\n  Instructions = 'instructions',\n  Skill = 'skill',\n  Connection = 'connection',\n  Schedule = 'schedule',\n  SandboxSelector = 'sandbox-selector',\n  BaseTools = 'base-tools',\n  HarnessHost = 'harness-host',\n  Hook = 'hook',\n  Channel = 'channel',\n  Approval = 'approval',\n}\n\nconst kinds = new WeakMap<object, AuthoredKind>();\n\nexport const stamp = <T extends object>(value: T, kind: AuthoredKind): T => {\n  kinds.set(value, kind);\n  return value;\n};\n\nexport const authoredKindOf = (value: AuthoredValue): AuthoredKind | null =>\n  isObjectLike(value) ? (kinds.get(value) ?? null) : null;\n\nexport const isAuthored = (value: AuthoredValue, kind: AuthoredKind): boolean =>\n  authoredKindOf(value) === kind;\n\n// Values whose bundle export is unknown where they are created (a custom\n// harness, a custom credential resolver): authoring records them in order and\n// hands out a placeholder; the compiler maps each placeholder to a synthesized\n// bundle export. Evaluation order is the bundle's module order, so the\n// compile-time evaluation and the isolate agree on the numbering.\nconst PENDING_PREFIX = '<pending:';\nconst pendingValues: AuthoredValue[] = [];\n\nexport const registerPending = (value: AuthoredValue): string => {\n  pendingValues.push(value);\n  return `${PENDING_PREFIX}${pendingValues.length - 1}>`;\n};\n\nexport const pendingEntries = (): { placeholder: string; index: number; value: AuthoredValue }[] =>\n  pendingValues.map((value, index) => ({\n    placeholder: `${PENDING_PREFIX}${index}>`,\n    index,\n    value,\n  }));\n\nexport const pendingIndexOf = (placeholder: string): number | null => {\n  const match = /^<pending:(\\d+)>$/.exec(placeholder);\n  return match?.[1] == null ? null : Number(match[1]);\n};\n\nexport const pendingExportName = (index: number): string => `pending:${index}`;\n"],
+  "mappings": "AAAA,SAAS,oBAAwC;AAO1C,IAAK,eAAL,kBAAKA,kBAAL;AACL,EAAAA,cAAA,WAAQ;AACR,EAAAA,cAAA,UAAO;AACP,EAAAA,cAAA,aAAU;AACV,EAAAA,cAAA,kBAAe;AACf,EAAAA,cAAA,WAAQ;AACR,EAAAA,cAAA,gBAAa;AACb,EAAAA,cAAA,cAAW;AACX,EAAAA,cAAA,qBAAkB;AAClB,EAAAA,cAAA,eAAY;AACZ,EAAAA,cAAA,iBAAc;AACd,EAAAA,cAAA,UAAO;AACP,EAAAA,cAAA,aAAU;AACV,EAAAA,cAAA,cAAW;AAbD,SAAAA;AAAA,GAAA;AAgBZ,MAAM,QAAQ,oBAAI,QAA8B;AAEzC,MAAM,QAAQ,CAAmB,OAAU,SAA0B;AAC1E,QAAM,IAAI,OAAO,IAAI;AACrB,SAAO;AACT;AAEO,MAAM,iBAAiB,CAAC,UAC7B,aAAa,KAAK,IAAK,MAAM,IAAI,KAAK,KAAK,OAAQ;AAE9C,MAAM,aAAa,CAAC,OAAsB,SAC/C,eAAe,KAAK,MAAM;AAO5B,MAAM,iBAAiB;AACvB,MAAM,gBAAiC,CAAC;AAEjC,MAAM,kBAAkB,CAAC,UAAiC;AAC/D,gBAAc,KAAK,KAAK;AACxB,SAAO,GAAG,cAAc,GAAG,cAAc,SAAS,CAAC;AACrD;AAEO,MAAM,iBAAiB,MAC5B,cAAc,IAAI,CAAC,OAAO,WAAW;AAAA,EACnC,aAAa,GAAG,cAAc,GAAG,KAAK;AAAA,EACtC;AAAA,EACA;AACF,EAAE;AAEG,MAAM,iBAAiB,CAAC,gBAAuC;AACpE,QAAM,QAAQ,oBAAoB,KAAK,WAAW;AAClD,SAAO,QAAQ,CAAC,KAAK,OAAO,OAAO,OAAO,MAAM,CAAC,CAAC;AACpD;AAEO,MAAM,oBAAoB,CAAC,UAA0B,WAAW,KAAK;",
+  "names": ["AuthoredKind"]
+}

package/dist/modules/authoring/channels.d.mts

@@ -0,0 +1,41 @@
+import type { AcpUpdateKind, ChannelAddressContextIface, ChannelDefinitionIface, ChannelEventHandler, ChannelReceiveContextIface, ChannelReceiveResult, ChannelSemanticDataByKindIface, HttpChannelRouteDefinitionIface, JsonObject, JsonValue, PendingEventKind, ProjectionContextIface, TurnPolicy, WebSocketChannelRouteDefinitionIface } from '@finalai/agent-provider';
+export type RouteHandler = HttpChannelRouteDefinitionIface['handler'];
+export type RouteHandlerArgsIface = Parameters<RouteHandler>[0];
+export type AuthoredChannelDefinitionIface = Partial<Omit<ChannelDefinitionIface<JsonValue, JsonValue>, 'turnPolicy' | 'events' | 'receive'>> & {
+    receive?: (input: JsonValue, ctx: ChannelReceiveContextIface & ChannelAddressContextIface) => Promise<ChannelReceiveResult>;
+    events?: Partial<Record<AcpUpdateKind | `${PendingEventKind}`, ChannelEventHandler>> & AuthoredSemanticEventsIface;
+    readonly turnPolicy?: TurnPolicy | `${TurnPolicy}`;
+    readonly config?: JsonObject;
+    readonly disabled?: boolean;
+};
+export interface AuthoredChannelContextIface extends ChannelAddressContextIface {
+    platform: ProjectionContextIface['platform'];
+}
+export interface AuthoredSessionContextIface {
+    sessionId: string | null;
+    turnId: string;
+    state: ProjectionContextIface['state'];
+}
+export type AuthoredSemanticEventsIface = {
+    [Kind in keyof ChannelSemanticDataByKindIface]?: (data: ChannelSemanticDataByKindIface[Kind], channel: AuthoredChannelContextIface, ctx: AuthoredSessionContextIface) => void | Promise<void>;
+};
+export declare const defineChannel: <TChannel extends AuthoredChannelDefinitionIface>(definition: TChannel) => Omit<TChannel, "installed" | "configure"> & {
+    configure: ((config: JsonObject) => ChannelDefinitionIface<JsonValue, JsonValue>) | undefined;
+    events: {
+        [x: string]: ChannelEventHandler | undefined;
+    };
+};
+export declare const disableChannel: () => Omit<{
+    disabled: true;
+}, "installed" | "configure"> & {
+    configure: ((config: JsonObject) => ChannelDefinitionIface<JsonValue, JsonValue>) | undefined;
+    events: {
+        [x: string]: ChannelEventHandler | undefined;
+    };
+};
+export declare const GET: (path: string, handler: RouteHandler) => HttpChannelRouteDefinitionIface;
+export declare const POST: (path: string, handler: RouteHandler) => HttpChannelRouteDefinitionIface;
+export declare const PUT: (path: string, handler: RouteHandler) => HttpChannelRouteDefinitionIface;
+export declare const DELETE: (path: string, handler: RouteHandler) => HttpChannelRouteDefinitionIface;
+export declare const WS: (path: string, handler: WebSocketChannelRouteDefinitionIface["handler"]) => WebSocketChannelRouteDefinitionIface;
+export declare const defineProviderChannel: <T extends ChannelDefinitionIface<JsonValue, JsonValue>>(definition: T) => T;

package/dist/modules/authoring/channels.mjs

@@ -0,0 +1,65 @@
+import {
+  channelAccessors,
+  channelMessageCompletedSchema,
+  jsonObjectSchema
+} from "@finalai/agent-provider";
+import * as z from "zod";
+import { AuthoredKind, stamp } from "./brand.mjs";
+const defineChannel = (definition) => {
+  const {
+    "message.delta": delta,
+    "message.completed": completed,
+    "turn.started": started,
+    "turn.completed": ended,
+    ...raw
+  } = definition.events ?? {};
+  const events = { ...raw };
+  const wrap = (schema, handler) => handler == null ? void 0 : async (event, ctx) => handler(
+    schema.parse(event.data),
+    { ...channelAccessors(ctx.platform), platform: ctx.platform },
+    {
+      sessionId: ctx.sessionId ?? null,
+      turnId: ctx.turn.id,
+      state: ctx.state
+    }
+  );
+  const semantic = {
+    "message.delta": wrap(z.object({ messageId: z.string(), delta: jsonObjectSchema }), delta),
+    "message.completed": wrap(channelMessageCompletedSchema, completed),
+    "turn.started": wrap(z.object({ turnId: z.string() }), started),
+    "turn.completed": wrap(
+      z.object({ turnId: z.string(), stopReason: z.string().nullable() }),
+      ended
+    )
+  };
+  for (const [kind, handler] of Object.entries(semantic))
+    if (handler != null) events[kind] = handler;
+  const { installed, configure, ...authored } = definition;
+  return stamp(
+    { ...authored, configure: installed == null ? configure : void 0, events },
+    AuthoredKind.Channel
+  );
+};
+const disableChannel = () => defineChannel({ disabled: true });
+const route = (method) => (path, handler) => ({
+  method,
+  path,
+  handler
+});
+const GET = route("GET");
+const POST = route("POST");
+const PUT = route("PUT");
+const DELETE = route("DELETE");
+const WS = (path, handler) => ({ method: "WS", path, handler });
+const defineProviderChannel = (definition) => stamp(definition, AuthoredKind.Channel);
+export {
+  DELETE,
+  GET,
+  POST,
+  PUT,
+  WS,
+  defineChannel,
+  defineProviderChannel,
+  disableChannel
+};
+//# sourceMappingURL=channels.mjs.map

package/dist/modules/authoring/channels.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/authoring/channels.ts"],
+  "sourcesContent": ["import type {\n  AcpUpdateKind,\n  ChannelAddressContextIface,\n  ChannelDefinitionIface,\n  ChannelEventHandler,\n  ChannelReceiveContextIface,\n  ChannelReceiveResult,\n  ChannelSemanticDataByKindIface,\n  HttpChannelRouteDefinitionIface,\n  JsonObject,\n  JsonValue,\n  PendingEventKind,\n  ProjectionContextIface,\n  TurnPolicy,\n  WebSocketChannelRouteDefinitionIface,\n} from '@finalai/agent-provider';\nimport {\n  channelAccessors,\n  channelMessageCompletedSchema,\n  jsonObjectSchema,\n} from '@finalai/agent-provider';\nimport * as z from 'zod';\nimport { AuthoredKind, stamp } from \"./brand.mjs\";\n\n// A custom channel in channels/<stem>.ts. Its routes run\n// in the agent's Worker isolate and are mounted by the session service's\n// front door at /<org>/<agent>/<stem><path> (and /b/<bindingId><path>);\n// the members it authors (receive, route, project, events) run there too,\n// driven by the session service exactly like a built-in channel's. What it\n// leaves out is the platform default: receive takes `{ target, content }`,\n// route follows the default routing rules, and the conversation's own channel projects.\n//\n// A bundle channel sees wire ids everywhere (conversations `conv_\u2026`,\n// participants `cpart_\u2026`, messages `cnmsg_\u2026`, users `usr_\u2026`, its binding\n// `chbind_\u2026`, turns `atrn_\u2026`, pending requests `apnd_\u2026`), the same strings the\n// public API returns, and must pass wire ids back to `ctx.platform`, `receive`\n// results and route decisions; raw UUIDs are refused.\n\nexport type RouteHandler = HttpChannelRouteDefinitionIface['handler'];\nexport type RouteHandlerArgsIface = Parameters<RouteHandler>[0];\n\nexport type AuthoredChannelDefinitionIface = Partial<\n  Omit<ChannelDefinitionIface<JsonValue, JsonValue>, 'turnPolicy' | 'events' | 'receive'>\n> & {\n  receive?: (\n    input: JsonValue,\n    ctx: ChannelReceiveContextIface & ChannelAddressContextIface,\n  ) => Promise<ChannelReceiveResult>;\n  events?: Partial<Record<AcpUpdateKind | `${PendingEventKind}`, ChannelEventHandler>> &\n    AuthoredSemanticEventsIface;\n  readonly turnPolicy?: TurnPolicy | `${TurnPolicy}`;\n  // Static binding config recorded in the manifest.\n  readonly config?: JsonObject;\n  readonly disabled?: boolean;\n};\n\nexport interface AuthoredChannelContextIface extends ChannelAddressContextIface {\n  platform: ProjectionContextIface['platform'];\n}\nexport interface AuthoredSessionContextIface {\n  sessionId: string | null;\n  turnId: string;\n  state: ProjectionContextIface['state'];\n}\nexport type AuthoredSemanticEventsIface = {\n  [Kind in keyof ChannelSemanticDataByKindIface]?: (\n    data: ChannelSemanticDataByKindIface[Kind],\n    channel: AuthoredChannelContextIface,\n    ctx: AuthoredSessionContextIface,\n  ) => void | Promise<void>;\n};\n\nexport const defineChannel = <TChannel extends AuthoredChannelDefinitionIface>(\n  definition: TChannel,\n) => {\n  const {\n    'message.delta': delta,\n    'message.completed': completed,\n    'turn.started': started,\n    'turn.completed': ended,\n    ...raw\n  } = definition.events ?? {};\n  const events = { ...raw };\n  const wrap = <Data>(\n    schema: z.ZodType<Data>,\n    handler:\n      | ((\n          data: Data,\n          channel: AuthoredChannelContextIface,\n          ctx: AuthoredSessionContextIface,\n        ) => void | Promise<void>)\n      | undefined,\n  ): ChannelEventHandler | undefined =>\n    handler == null\n      ? undefined\n      : async (event, ctx) =>\n          handler(\n            schema.parse(event.data),\n            { ...channelAccessors(ctx.platform), platform: ctx.platform },\n            {\n              sessionId: ctx.sessionId ?? null,\n              turnId: ctx.turn.id,\n              state: ctx.state,\n            },\n          );\n  const semantic = {\n    'message.delta': wrap(z.object({ messageId: z.string(), delta: jsonObjectSchema }), delta),\n    'message.completed': wrap(channelMessageCompletedSchema, completed),\n    'turn.started': wrap(z.object({ turnId: z.string() }), started),\n    'turn.completed': wrap(\n      z.object({ turnId: z.string(), stopReason: z.string().nullable() }),\n      ended,\n    ),\n  };\n  for (const [kind, handler] of Object.entries(semantic))\n    if (handler != null) events[kind] = handler;\n  const { installed, configure, ...authored } = definition;\n  return stamp(\n    { ...authored, configure: installed == null ? configure : undefined, events },\n    AuthoredKind.Channel,\n  );\n};\n\nexport const disableChannel = () => defineChannel({ disabled: true });\n\nconst route =\n  (method: HttpChannelRouteDefinitionIface['method']) =>\n  (path: string, handler: RouteHandler): HttpChannelRouteDefinitionIface => ({\n    method,\n    path,\n    handler,\n  });\n\nexport const GET = route('GET');\nexport const POST = route('POST');\nexport const PUT = route('PUT');\nexport const DELETE = route('DELETE');\n\nexport const WS = (\n  path: string,\n  handler: WebSocketChannelRouteDefinitionIface['handler'],\n): WebSocketChannelRouteDefinitionIface => ({ method: 'WS', path, handler });\n\n// Provider factories already own their installed reference and runtime handlers.\nexport const defineProviderChannel = <T extends ChannelDefinitionIface<JsonValue, JsonValue>>(\n  definition: T,\n): T => stamp(definition, AuthoredKind.Channel);\n"],
+  "mappings": "AAgBA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,YAAY,OAAO;AACnB,SAAS,cAAc,aAAa;AAkD7B,MAAM,gBAAgB,CAC3B,eACG;AACH,QAAM;AAAA,IACJ,iBAAiB;AAAA,IACjB,qBAAqB;AAAA,IACrB,gBAAgB;AAAA,IAChB,kBAAkB;AAAA,IAClB,GAAG;AAAA,EACL,IAAI,WAAW,UAAU,CAAC;AAC1B,QAAM,SAAS,EAAE,GAAG,IAAI;AACxB,QAAM,OAAO,CACX,QACA,YAQA,WAAW,OACP,SACA,OAAO,OAAO,QACZ;AAAA,IACE,OAAO,MAAM,MAAM,IAAI;AAAA,IACvB,EAAE,GAAG,iBAAiB,IAAI,QAAQ,GAAG,UAAU,IAAI,SAAS;AAAA,IAC5D;AAAA,MACE,WAAW,IAAI,aAAa;AAAA,MAC5B,QAAQ,IAAI,KAAK;AAAA,MACjB,OAAO,IAAI;AAAA,IACb;AAAA,EACF;AACR,QAAM,WAAW;AAAA,IACf,iBAAiB,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,OAAO,GAAG,OAAO,iBAAiB,CAAC,GAAG,KAAK;AAAA,IACzF,qBAAqB,KAAK,+BAA+B,SAAS;AAAA,IAClE,gBAAgB,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,GAAG,OAAO;AAAA,IAC9D,kBAAkB;AAAA,MAChB,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,GAAG,YAAY,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC;AAAA,MAClE;AAAA,IACF;AAAA,EACF;AACA,aAAW,CAAC,MAAM,OAAO,KAAK,OAAO,QAAQ,QAAQ;AACnD,QAAI,WAAW,KAAM,QAAO,IAAI,IAAI;AACtC,QAAM,EAAE,WAAW,WAAW,GAAG,SAAS,IAAI;AAC9C,SAAO;AAAA,IACL,EAAE,GAAG,UAAU,WAAW,aAAa,OAAO,YAAY,QAAW,OAAO;AAAA,IAC5E,aAAa;AAAA,EACf;AACF;AAEO,MAAM,iBAAiB,MAAM,cAAc,EAAE,UAAU,KAAK,CAAC;AAEpE,MAAM,QACJ,CAAC,WACD,CAAC,MAAc,aAA4D;AAAA,EACzE;AAAA,EACA;AAAA,EACA;AACF;AAEK,MAAM,MAAM,MAAM,KAAK;AACvB,MAAM,OAAO,MAAM,MAAM;AACzB,MAAM,MAAM,MAAM,KAAK;AACvB,MAAM,SAAS,MAAM,QAAQ;AAE7B,MAAM,KAAK,CAChB,MACA,aAC0C,EAAE,QAAQ,MAAM,MAAM,QAAQ;AAGnE,MAAM,wBAAwB,CACnC,eACM,MAAM,YAAY,aAAa,OAAO;",
+  "names": []
+}

package/dist/modules/authoring/connections.d.mts

@@ -0,0 +1,23 @@
+import type { ApprovalPolicyIface } from "./approval.mjs";
+export type McpConnectionAuthIface = {
+    readonly secretKey: string;
+    readonly headerName: string | null;
+} | {
+    readonly kind: 'final-session';
+};
+export interface McpConnectionToolsIface {
+    readonly allow?: readonly string[];
+    readonly deny?: readonly string[];
+    readonly approval?: Readonly<Record<string, ApprovalPolicyIface<never>>>;
+}
+export interface McpClientConnectionDefinitionIface {
+    readonly url: string;
+    readonly description?: string;
+    readonly auth?: McpConnectionAuthIface;
+    readonly headers?: Readonly<Record<string, string>>;
+    readonly tools?: McpConnectionToolsIface;
+    readonly approval?: ApprovalPolicyIface<never>;
+    readonly protocolVersionDiscovery?: boolean;
+    readonly instanceKey?: string;
+}
+export declare const defineMcpClientConnection: <TConnection extends McpClientConnectionDefinitionIface>(definition: TConnection) => TConnection;

package/dist/modules/authoring/connections.mjs

@@ -0,0 +1,6 @@
+import { AuthoredKind, stamp } from "./brand.mjs";
+const defineMcpClientConnection = (definition) => stamp({ ...definition }, AuthoredKind.Connection);
+export {
+  defineMcpClientConnection
+};
+//# sourceMappingURL=connections.mjs.map

package/dist/modules/authoring/connections.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/authoring/connections.ts"],
+  "sourcesContent": ["import type { ApprovalPolicyIface } from \"./approval.mjs\";\nimport { AuthoredKind, stamp } from \"./brand.mjs\";\n\n// An MCP connection. Secrets are references by\n// name: the MCP host injects them, so they never reach the harness. Final's\n// own MCP server is an ordinary connection with `auth: { kind: 'final-session' }`.\n\nexport type McpConnectionAuthIface =\n  // Sent as `Authorization: Bearer <secret>` when headerName is null.\n  | { readonly secretKey: string; readonly headerName: string | null }\n  | { readonly kind: 'final-session' };\n\nexport interface McpConnectionToolsIface {\n  // Only these tools are exposed; omit to expose every tool the server lists.\n  readonly allow?: readonly string[];\n  // These tools are hidden, whatever `allow` says.\n  readonly deny?: readonly string[];\n  // Per-tool approval; tools not listed use the connection's `approval`.\n  readonly approval?: Readonly<Record<string, ApprovalPolicyIface<never>>>;\n}\n\nexport interface McpClientConnectionDefinitionIface {\n  readonly url: string;\n  readonly description?: string;\n  readonly auth?: McpConnectionAuthIface;\n  readonly headers?: Readonly<Record<string, string>>;\n  readonly tools?: McpConnectionToolsIface;\n  // Default approval for every tool of this connection.\n  readonly approval?: ApprovalPolicyIface<never>;\n  readonly protocolVersionDiscovery?: boolean;\n  readonly instanceKey?: string;\n}\n\nexport const defineMcpClientConnection = <TConnection extends McpClientConnectionDefinitionIface>(\n  definition: TConnection,\n): TConnection => stamp({ ...definition }, AuthoredKind.Connection);\n"],
+  "mappings": "AACA,SAAS,cAAc,aAAa;AAgC7B,MAAM,4BAA4B,CACvC,eACgB,MAAM,EAAE,GAAG,WAAW,GAAG,aAAa,UAAU;",
+  "names": []
+}

package/dist/modules/authoring/context.d.mts

@@ -0,0 +1,83 @@
+import type { ConversationMessageIface } from '@finalai/agent-protocol/agent-platform';
+import type { ConversationKind, JsonObject, JsonValue, NetworkSandboxSessionIface, ParticipantKind, ProviderRef } from '@finalai/agent-provider';
+export interface ParticipantInfoIface {
+    id: string;
+    kind: ParticipantKind;
+    displayName: string;
+    userId: string | null;
+}
+export interface ConversationInfoIface {
+    id: string;
+    kind: ConversationKind;
+    title: string | null;
+    metadata: JsonObject;
+    participants: ParticipantInfoIface[];
+}
+export interface PromptAuthorIface {
+    participantId: string | null;
+    userId: string | null;
+    displayName: string;
+}
+export interface AgentSessionInfoIface {
+    id: string;
+    organizationId: string;
+    definitionId: string;
+    revisionId: string;
+    conversation: ConversationInfoIface | null;
+    author: PromptAuthorIface | null;
+    turn: {
+        id: string;
+    } | null;
+    harness: ProviderRef;
+}
+export declare enum TranscriptRole {
+    User = "user",
+    Assistant = "assistant",
+    Tool = "tool",
+    Thought = "thought",
+    Summary = "summary"
+}
+export interface TranscriptMessageIface {
+    role: TranscriptRole;
+    content: JsonValue[];
+    toolCallId: string | null;
+    seq: number;
+}
+export interface SecretsIface {
+    get(name: string): Promise<string | null>;
+}
+export interface PostMessageInputIface {
+    text?: string;
+    content?: JsonValue[];
+    conversationId?: string;
+}
+export interface FinalPlatformClientIface {
+    post(input: PostMessageInputIface): Promise<{
+        messageId: string;
+    }>;
+    conversation(): Promise<ConversationInfoIface | null>;
+    read(options?: {
+        conversationId?: string;
+        limit?: number;
+        before?: string;
+    }): Promise<ConversationMessageIface[]>;
+}
+export interface ToolContextIface {
+    readonly session: AgentSessionInfoIface;
+    readonly callId: string;
+    readonly toolName: string;
+    readonly abortSignal: AbortSignal;
+    getSandbox(target?: string): Promise<NetworkSandboxSessionIface>;
+    readonly messages: readonly TranscriptMessageIface[];
+    readonly secrets: SecretsIface;
+    readonly final: FinalPlatformClientIface;
+}
+export interface DynamicResolveContextIface {
+    readonly previousValue?: JsonValue | null;
+    readonly session: AgentSessionInfoIface;
+    readonly messages: readonly TranscriptMessageIface[];
+    readonly channel: {
+        kind: string | null;
+    };
+    readonly secrets: SecretsIface;
+}

package/dist/modules/authoring/context.mjs

@@ -0,0 +1,12 @@
+var TranscriptRole = /* @__PURE__ */ ((TranscriptRole2) => {
+  TranscriptRole2["User"] = "user";
+  TranscriptRole2["Assistant"] = "assistant";
+  TranscriptRole2["Tool"] = "tool";
+  TranscriptRole2["Thought"] = "thought";
+  TranscriptRole2["Summary"] = "summary";
+  return TranscriptRole2;
+})(TranscriptRole || {});
+export {
+  TranscriptRole
+};
+//# sourceMappingURL=context.mjs.map

package/dist/modules/authoring/context.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/authoring/context.ts"],
+  "sourcesContent": ["import type { ConversationMessageIface } from '@finalai/agent-protocol/agent-platform';\nimport type {\n  ConversationKind,\n  JsonObject,\n  JsonValue,\n  NetworkSandboxSessionIface,\n  ParticipantKind,\n  ProviderRef,\n} from '@finalai/agent-provider';\n\n// What authored code (tools, hooks, dynamic resolvers, channel routes) sees of\n// the session it runs for. Everything is provided by\n// the session service through the Worker isolate; none of it is harness state.\n//\n// Ids are the public API's wire ids (`<prefix>_<base58>`), the same strings the\n// client SDK and `/api/v1` return: a session is `ases_\u2026`, a conversation\n// `conv_\u2026`, a participant `cpart_\u2026`, a turn `atrn_\u2026`, a user `usr_\u2026`. Pass them\n// back unchanged (`ctx.final.post({ conversationId })`, channel platform\n// calls); raw UUIDs are refused. ACP ids (`toolCallId`, prompt message ids)\n// and provider or model ids are passed through as the harness sent them.\n\nexport interface ParticipantInfoIface {\n  // `cpart_\u2026`; `userId` is `usr_\u2026`.\n  id: string;\n  kind: ParticipantKind;\n  displayName: string;\n  userId: string | null;\n}\n\nexport interface ConversationInfoIface {\n  // `conv_\u2026`, as `client` and `/api/v1/conversations` name it.\n  id: string;\n  kind: ConversationKind;\n  title: string | null;\n  metadata: JsonObject;\n  participants: ParticipantInfoIface[];\n}\n\nexport interface PromptAuthorIface {\n  participantId: string | null;\n  userId: string | null;\n  displayName: string;\n}\n\nexport interface AgentSessionInfoIface {\n  // `ases_\u2026`: what `client.sessions.attach(id)` takes.\n  id: string;\n  // `org_\u2026`.\n  organizationId: string;\n  // The agent (`adef_\u2026`) and its published revision (`arev_\u2026`).\n  definitionId: string;\n  revisionId: string;\n  conversation: ConversationInfoIface | null;\n  // Who prompted the current turn; null outside a turn and for system input.\n  author: PromptAuthorIface | null;\n  // `atrn_\u2026`.\n  turn: { id: string } | null;\n  harness: ProviderRef;\n}\n\nexport enum TranscriptRole {\n  User = 'user',\n  Assistant = 'assistant',\n  Tool = 'tool',\n  Thought = 'thought',\n  Summary = 'summary',\n}\n\n// One entry of the transcript rebuilt from the session's ACP log. Not the\n// harness's byte-exact model input (no system prompt).\nexport interface TranscriptMessageIface {\n  role: TranscriptRole;\n  // ACP content blocks.\n  content: JsonValue[];\n  toolCallId: string | null;\n  seq: number;\n}\n\nexport interface SecretsIface {\n  get(name: string): Promise<string | null>;\n}\n\nexport interface PostMessageInputIface {\n  text?: string;\n  // ACP content blocks; appended after `text` when both are given.\n  content?: JsonValue[];\n  // A `conv_\u2026` id; defaults to the session's conversation.\n  conversationId?: string;\n}\n\n// The agent-platform client handed to authored code (a Final addition).\nexport interface FinalPlatformClientIface {\n  // Resolves the posted message's `cnmsg_\u2026` id.\n  post(input: PostMessageInputIface): Promise<{ messageId: string }>;\n  conversation(): Promise<ConversationInfoIface | null>;\n  // The current conversation's visible history, oldest first within the page.\n  // `before` is a cnmsg_\u2026 id; other conversations are refused by the platform.\n  read(options?: {\n    conversationId?: string;\n    limit?: number;\n    before?: string;\n  }): Promise<ConversationMessageIface[]>;\n}\n\nexport interface ToolContextIface {\n  readonly session: AgentSessionInfoIface;\n  // The MCP request id the harness chose; shows up as the ACP toolCallId.\n  readonly callId: string;\n  // Qualified name as the harness saw it.\n  readonly toolName: string;\n  readonly abortSignal: AbortSignal;\n  // The same handle the sandbox MCP server uses; the first call starts the\n  // sandbox. Defaults to the definition's default target.\n  getSandbox(target?: string): Promise<NetworkSandboxSessionIface>;\n  readonly messages: readonly TranscriptMessageIface[];\n  readonly secrets: SecretsIface;\n  readonly final: FinalPlatformClientIface;\n}\n\nexport interface DynamicResolveContextIface {\n  // The persisted value of this slot at its previous lifecycle boundary.\n  readonly previousValue?: JsonValue | null;\n  readonly session: AgentSessionInfoIface;\n  // The transcript at the boundary (empty at session.started for a new session).\n  readonly messages: readonly TranscriptMessageIface[];\n  readonly channel: { kind: string | null };\n  readonly secrets: SecretsIface;\n}\n"],
+  "mappings": "AA4DO,IAAK,iBAAL,kBAAKA,oBAAL;AACL,EAAAA,gBAAA,UAAO;AACP,EAAAA,gBAAA,eAAY;AACZ,EAAAA,gBAAA,UAAO;AACP,EAAAA,gBAAA,aAAU;AACV,EAAAA,gBAAA,aAAU;AALA,SAAAA;AAAA,GAAA;",
+  "names": ["TranscriptRole"]
+}

package/dist/modules/authoring/credentials.d.mts

@@ -0,0 +1,10 @@
+import { credentials as contractCredentials, type CustomNodeIface } from '@finalai/agent-provider';
+import type { DynamicSentinelIface } from "./dynamic.mjs";
+type CustomResolverInput = DynamicSentinelIface | Parameters<typeof contractCredentials.custom>[0];
+declare const custom: (resolver: CustomResolverInput) => CustomNodeIface;
+export interface AuthoredCredentialsIface extends Omit<typeof contractCredentials, 'custom'> {
+    custom: typeof custom;
+}
+export declare const credentials: AuthoredCredentialsIface;
+export { CredentialOwner, CredentialPayer, defaultOrganizationCredentialPolicy, defaultPersonalCredentialPolicy, } from '@finalai/agent-provider';
+export type { CredentialNode, CredentialPolicyIface } from '@finalai/agent-provider';

package/dist/modules/authoring/credentials.mjs

@@ -0,0 +1,31 @@
+import {
+  credentials as contractCredentials,
+  DynamicEvent
+} from "@finalai/agent-provider";
+import { AuthoredKind, isAuthored, registerPending } from "./brand.mjs";
+const DYNAMIC_EVENTS = Object.values(DynamicEvent);
+const eventsOf = (sentinel) => DYNAMIC_EVENTS.filter((event) => sentinel.events[event] != null);
+const isSentinel = (value) => isAuthored(value, AuthoredKind.Dynamic);
+const custom = (resolver) => {
+  if (!isSentinel(resolver)) return contractCredentials.custom(resolver);
+  const events = eventsOf(resolver);
+  return contractCredentials.custom({
+    resolverExport: registerPending(resolver),
+    events: events.length === 0 ? [DynamicEvent.SessionStarted] : events
+  });
+};
+const credentials = { ...contractCredentials, custom };
+import {
+  CredentialOwner,
+  CredentialPayer,
+  defaultOrganizationCredentialPolicy,
+  defaultPersonalCredentialPolicy
+} from "@finalai/agent-provider";
+export {
+  CredentialOwner,
+  CredentialPayer,
+  credentials,
+  defaultOrganizationCredentialPolicy,
+  defaultPersonalCredentialPolicy
+};
+//# sourceMappingURL=credentials.mjs.map

package/dist/modules/authoring/credentials.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/authoring/credentials.ts"],
+  "sourcesContent": ["import {\n  credentials as contractCredentials,\n  DynamicEvent,\n  type CustomNodeIface,\n} from '@finalai/agent-provider';\nimport { AuthoredKind, isAuthored, registerPending } from \"./brand.mjs\";\nimport type { DynamicSentinelIface } from \"./dynamic.mjs\";\n\nconst DYNAMIC_EVENTS: readonly DynamicEvent[] = Object.values(DynamicEvent);\n\nconst eventsOf = (sentinel: DynamicSentinelIface): DynamicEvent[] =>\n  DYNAMIC_EVENTS.filter((event) => sentinel.events[event] != null);\n\ntype CustomResolverInput = DynamicSentinelIface | Parameters<typeof contractCredentials.custom>[0];\n\nconst isSentinel = (value: CustomResolverInput): value is DynamicSentinelIface =>\n  isAuthored(value, AuthoredKind.Dynamic);\n\n// `credentials.custom(defineDynamic({...}))`: the resolver\n// stays in the bundle; the manifest records its synthesized export name.\nconst custom = (resolver: CustomResolverInput): CustomNodeIface => {\n  if (!isSentinel(resolver)) return contractCredentials.custom(resolver);\n  const events = eventsOf(resolver);\n  return contractCredentials.custom({\n    resolverExport: registerPending(resolver),\n    events: events.length === 0 ? [DynamicEvent.SessionStarted] : events,\n  });\n};\n\nexport interface AuthoredCredentialsIface extends Omit<typeof contractCredentials, 'custom'> {\n  custom: typeof custom;\n}\n\nexport const credentials: AuthoredCredentialsIface = { ...contractCredentials, custom };\n\nexport {\n  CredentialOwner,\n  CredentialPayer,\n  defaultOrganizationCredentialPolicy,\n  defaultPersonalCredentialPolicy,\n} from '@finalai/agent-provider';\nexport type { CredentialNode, CredentialPolicyIface } from '@finalai/agent-provider';\n"],
+  "mappings": "AAAA;AAAA,EACE,eAAe;AAAA,EACf;AAAA,OAEK;AACP,SAAS,cAAc,YAAY,uBAAuB;AAG1D,MAAM,iBAA0C,OAAO,OAAO,YAAY;AAE1E,MAAM,WAAW,CAAC,aAChB,eAAe,OAAO,CAAC,UAAU,SAAS,OAAO,KAAK,KAAK,IAAI;AAIjE,MAAM,aAAa,CAAC,UAClB,WAAW,OAAO,aAAa,OAAO;AAIxC,MAAM,SAAS,CAAC,aAAmD;AACjE,MAAI,CAAC,WAAW,QAAQ,EAAG,QAAO,oBAAoB,OAAO,QAAQ;AACrE,QAAM,SAAS,SAAS,QAAQ;AAChC,SAAO,oBAAoB,OAAO;AAAA,IAChC,gBAAgB,gBAAgB,QAAQ;AAAA,IACxC,QAAQ,OAAO,WAAW,IAAI,CAAC,aAAa,cAAc,IAAI;AAAA,EAChE,CAAC;AACH;AAMO,MAAM,cAAwC,EAAE,GAAG,qBAAqB,OAAO;AAEtF;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;",
+  "names": []
+}