@finalai/agent-definition 0.1.0

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

@@ -0,0 +1,30 @@
+import type { ProviderRef } from '@finalai/agent-provider';
+import type { DynamicResolveContextIface } from "./context.mjs";
+export type DynamicHandler<TResult> = (event: DynamicBoundaryEventIface, ctx: DynamicResolveContextIface) => TResult | Promise<TResult>;
+export interface DynamicBoundaryEventIface {
+    type: 'session.started' | 'turn.started';
+    prompt: unknown[] | null;
+}
+export interface DynamicEventsIface<TResult> {
+    readonly 'session.started'?: DynamicHandler<TResult>;
+    readonly 'turn.started'?: DynamicHandler<TResult>;
+}
+export type DynamicProviderHint = ProviderRef | {
+    readonly name: string;
+} | {
+    readonly providerRef: ProviderRef;
+};
+export interface DynamicDefinitionIface<TResult> {
+    readonly events: DynamicEventsIface<TResult>;
+    readonly description?: string;
+    readonly preview?: string;
+    readonly provider?: DynamicProviderHint;
+}
+export interface DynamicSentinelIface<TResult = unknown> {
+    readonly kind: 'final:dynamic';
+    readonly events: DynamicEventsIface<TResult>;
+    readonly description?: string;
+    readonly preview?: string;
+    readonly provider?: DynamicProviderHint;
+}
+export declare const defineDynamic: <TResult>(definition: DynamicDefinitionIface<TResult>) => DynamicSentinelIface<TResult>;

package/dist/modules/authoring/dynamic.mjs

@@ -0,0 +1,15 @@
+import { AuthoredKind, stamp } from "./brand.mjs";
+const defineDynamic = (definition) => {
+  const sentinel = {
+    kind: "final:dynamic",
+    events: definition.events
+  };
+  if (definition.description != null) sentinel.description = definition.description;
+  if (definition.preview != null) sentinel.preview = definition.preview;
+  if (definition.provider != null) sentinel.provider = definition.provider;
+  return stamp(sentinel, AuthoredKind.Dynamic);
+};
+export {
+  defineDynamic
+};
+//# sourceMappingURL=dynamic.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/authoring/dynamic.ts"],
+  "sourcesContent": ["import type { ProviderRef } from '@finalai/agent-provider';\nimport { AuthoredKind, stamp } from \"./brand.mjs\";\nimport type { DynamicResolveContextIface } from \"./context.mjs\";\n\n// defineDynamic: a definition computed at a lifecycle\n// boundary. The directory a file sits in decides what a handler must return.\n// `description` and `preview` are Final additions so Build can render a slot\n// without resolving it.\n\nexport type DynamicHandler<TResult> = (\n  event: DynamicBoundaryEventIface,\n  ctx: DynamicResolveContextIface,\n) => TResult | Promise<TResult>;\n\nexport interface DynamicBoundaryEventIface {\n  type: 'session.started' | 'turn.started';\n  // The prompt that started the turn (turn.started only), as ACP content blocks.\n  prompt: unknown[] | null;\n}\n\nexport interface DynamicEventsIface<TResult> {\n  readonly 'session.started'?: DynamicHandler<TResult>;\n  readonly 'turn.started'?: DynamicHandler<TResult>;\n}\n\n// A sandbox target whose environment is dynamic still needs its provider at\n// compile time: an installed provider helper, a provider defined with\n// defineSandboxProvider, or a provider reference.\nexport type DynamicProviderHint =\n  | ProviderRef\n  | { readonly name: string }\n  | { readonly providerRef: ProviderRef };\n\nexport interface DynamicDefinitionIface<TResult> {\n  readonly events: DynamicEventsIface<TResult>;\n  readonly description?: string;\n  readonly preview?: string;\n  readonly provider?: DynamicProviderHint;\n}\n\nexport interface DynamicSentinelIface<TResult = unknown> {\n  readonly kind: 'final:dynamic';\n  readonly events: DynamicEventsIface<TResult>;\n  readonly description?: string;\n  readonly preview?: string;\n  readonly provider?: DynamicProviderHint;\n}\n\ninterface DynamicSentinelFieldsIface<TResult> {\n  kind: 'final:dynamic';\n  events: DynamicEventsIface<TResult>;\n  description?: string;\n  preview?: string;\n  provider?: DynamicProviderHint;\n}\n\nexport const defineDynamic = <TResult>(\n  definition: DynamicDefinitionIface<TResult>,\n): DynamicSentinelIface<TResult> => {\n  const sentinel: DynamicSentinelFieldsIface<TResult> = {\n    kind: 'final:dynamic',\n    events: definition.events,\n  };\n  if (definition.description != null) sentinel.description = definition.description;\n  if (definition.preview != null) sentinel.preview = definition.preview;\n  if (definition.provider != null) sentinel.provider = definition.provider;\n  return stamp(sentinel, AuthoredKind.Dynamic);\n};\n"],
+  "mappings": "AACA,SAAS,cAAc,aAAa;AAuD7B,MAAM,gBAAgB,CAC3B,eACkC;AAClC,QAAM,WAAgD;AAAA,IACpD,MAAM;AAAA,IACN,QAAQ,WAAW;AAAA,EACrB;AACA,MAAI,WAAW,eAAe,KAAM,UAAS,cAAc,WAAW;AACtE,MAAI,WAAW,WAAW,KAAM,UAAS,UAAU,WAAW;AAC9D,MAAI,WAAW,YAAY,KAAM,UAAS,WAAW,WAAW;AAChE,SAAO,MAAM,UAAU,aAAa,OAAO;AAC7C;",
+  "names": []
+}

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

@@ -0,0 +1,85 @@
+import { CredentialDelivery, InferenceCredentialKind, type AcpTransport, type DefinedHarnessBindingIface, type DescribeHarnessArgsIface, type HarnessClientTlsIface, type HarnessDescriptionIface, type HarnessSessionRefIface, type JsonSchema, type JsonValue, type McpTransportKind, type OpenHarnessSessionArgsIface, type PromptWhileRunning, type SandboxWire, type SecretReaderIface, type UserInstructionDelivery } from '@finalai/agent-provider';
+type EnumInput<E extends string> = E | `${E}`;
+export interface AuthoredHarnessDescriptionIface {
+    configSchema: JsonSchema;
+    userInstructionDelivery?: EnumInput<UserInstructionDelivery>;
+    acp: {
+        transports: readonly EnumInput<AcpTransport.Ws | AcpTransport.Http>[];
+        mcp?: readonly EnumInput<McpTransportKind>[];
+    };
+    baseTools?: HarnessDescriptionIface['baseTools'];
+    consumes?: readonly EnumInput<SandboxWire>[];
+    inference?: {
+        vendors?: readonly string[];
+        kinds?: readonly EnumInput<InferenceCredentialKind>[];
+        delivery?: EnumInput<CredentialDelivery>;
+    };
+    supports?: Partial<HarnessDescriptionIface['supports']>;
+    promptWhileRunning?: EnumInput<PromptWhileRunning>;
+    sessionSurvivesDisconnect?: boolean;
+}
+export interface AuthoredHarnessSessionRefIface {
+    harnessSessionRef: string;
+    generation: number;
+}
+export type AuthoredHarnessEndpointIface = {
+    ref: AuthoredHarnessSessionRefIface;
+    transport: EnumInput<AcpTransport.Ws>;
+    url: string;
+    headers?: Record<string, string>;
+    tls?: HarnessClientTlsIface;
+} | {
+    ref: AuthoredHarnessSessionRefIface;
+    transport: EnumInput<AcpTransport.Http>;
+    url: string;
+    headers?: Record<string, string>;
+    tls?: HarnessClientTlsIface;
+};
+export interface AuthoredHarnessOpenArgsIface<Config> extends Omit<OpenHarnessSessionArgsIface, 'config' | 'observer'> {
+    config: Config;
+    sessionId: string;
+}
+export interface AuthoredHarnessResumeArgsIface<Config> extends AuthoredHarnessOpenArgsIface<Config> {
+    ref: HarnessSessionRefIface;
+    lastSeq: number;
+}
+export type HarnessOpenCallIface<Config> = Omit<AuthoredHarnessOpenArgsIface<Config>, 'sessionId'>;
+export type HarnessResumeCallIface<Config> = Omit<AuthoredHarnessResumeArgsIface<Config>, 'sessionId'>;
+export interface AuthoredHarnessRefContextIface {
+    secrets: SecretReaderIface;
+}
+export interface AuthoredHarnessCloseContextIface extends AuthoredHarnessRefContextIface {
+    force: boolean;
+}
+export type AuthoredHarnessRefArgIface<Context extends AuthoredHarnessRefContextIface> = HarnessSessionRefIface & Context & {
+    ref: HarnessSessionRefIface;
+};
+export interface AuthoredHarnessHealthIface {
+    ok: boolean;
+    detail?: string;
+    checkedAt?: string;
+}
+export interface AuthoredHarnessIface<Config> {
+    describe(binding?: DescribeHarnessArgsIface): Promise<AuthoredHarnessDescriptionIface>;
+    open(args: AuthoredHarnessOpenArgsIface<Config>): Promise<AuthoredHarnessEndpointIface>;
+    resume(args: AuthoredHarnessResumeArgsIface<Config>): Promise<AuthoredHarnessEndpointIface>;
+    park(ref: AuthoredHarnessRefArgIface<AuthoredHarnessRefContextIface>, ctx: AuthoredHarnessRefContextIface): Promise<void>;
+    close(ref: AuthoredHarnessRefArgIface<AuthoredHarnessCloseContextIface>, ctx: AuthoredHarnessCloseContextIface): Promise<void>;
+    health(ref: AuthoredHarnessRefArgIface<AuthoredHarnessRefContextIface>, ctx: AuthoredHarnessRefContextIface): Promise<AuthoredHarnessHealthIface>;
+}
+export interface DefinedAuthoredHarnessIface<Config> {
+    (config: Config): DefinedHarnessBindingIface;
+    describe(binding?: DescribeHarnessArgsIface): Promise<HarnessDescriptionIface>;
+    open(args: HarnessOpenCallIface<Config>): Promise<AuthoredHarnessEndpointIface>;
+    resume(args: HarnessResumeCallIface<Config>): Promise<AuthoredHarnessEndpointIface>;
+    park(ref: HarnessSessionRefIface, ctx: AuthoredHarnessRefContextIface): Promise<void>;
+    close(ref: HarnessSessionRefIface, ctx: AuthoredHarnessCloseContextIface): Promise<void>;
+    health(ref: HarnessSessionRefIface, ctx: AuthoredHarnessRefContextIface): Promise<{
+        ok: boolean;
+        detail?: string;
+        checkedAt: string;
+    }>;
+}
+export declare const completeHarnessDescription: (authored: AuthoredHarnessDescriptionIface) => HarnessDescriptionIface;
+export declare const defineHarness: <Config extends JsonValue = JsonValue>(implementation: AuthoredHarnessIface<Config>) => DefinedAuthoredHarnessIface<Config>;
+export {};

package/dist/modules/authoring/harness.mjs

@@ -0,0 +1,55 @@
+import {
+  bundleRef,
+  CredentialDelivery,
+  harnessDescriptionSchema,
+  InferenceCredentialKind
+} from "@finalai/agent-provider";
+import { registerPending } from "./brand.mjs";
+const completeHarnessDescription = (authored) => {
+  const supports = {
+    observe: authored.supports?.observe ?? false,
+    resumeReplay: authored.supports?.resumeReplay ?? false,
+    fork: authored.supports?.fork ?? false,
+    authorMeta: authored.supports?.authorMeta ?? false
+  };
+  if (authored.supports?.nativeToolPolicy != null)
+    supports.nativeToolPolicy = authored.supports.nativeToolPolicy;
+  return harnessDescriptionSchema.parse({
+    ...authored,
+    acp: { transports: authored.acp.transports, mcp: authored.acp.mcp ?? [] },
+    baseTools: authored.baseTools ?? {},
+    consumes: authored.consumes ?? [],
+    inference: {
+      vendors: authored.inference?.vendors ?? [],
+      kinds: authored.inference?.kinds ?? [InferenceCredentialKind.HarnessOwned],
+      delivery: authored.inference?.delivery ?? CredentialDelivery.AtOpen
+    },
+    supports
+  });
+};
+const defineHarness = (implementation) => {
+  let placeholder = null;
+  const binding = (config) => ({
+    harness: placeholder ?? bundleRef("<pending>"),
+    config,
+    definedHarness: true
+  });
+  const defined = Object.assign(binding, {
+    describe: async (args) => completeHarnessDescription(await implementation.describe(args)),
+    open: (args) => implementation.open({ ...args, sessionId: args.session.sessionId }),
+    resume: (args) => implementation.resume({ ...args, sessionId: args.session.sessionId }),
+    park: (ref, ctx) => implementation.park({ ...ref, ...ctx, ref }, ctx),
+    close: (ref, ctx) => implementation.close({ ...ref, ...ctx, ref }, ctx),
+    health: async (ref, ctx) => {
+      const health = await implementation.health({ ...ref, ...ctx, ref }, ctx);
+      return { ...health, checkedAt: health.checkedAt ?? (/* @__PURE__ */ new Date()).toISOString() };
+    }
+  });
+  placeholder = bundleRef(registerPending(defined));
+  return defined;
+};
+export {
+  completeHarnessDescription,
+  defineHarness
+};
+//# sourceMappingURL=harness.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/authoring/harness.ts"],
+  "sourcesContent": ["import {\n  bundleRef,\n  CredentialDelivery,\n  harnessDescriptionSchema,\n  InferenceCredentialKind,\n  type AcpTransport,\n  type DefinedHarnessBindingIface,\n  type DescribeHarnessArgsIface,\n  type HarnessClientTlsIface,\n  type HarnessDescriptionIface,\n  type HarnessSessionRefIface,\n  type JsonSchema,\n  type JsonValue,\n  type McpTransportKind,\n  type OpenHarnessSessionArgsIface,\n  type PromptWhileRunning,\n  type ProviderRef,\n  type SandboxWire,\n  type SecretReaderIface,\n  type UserInstructionDelivery,\n} from '@finalai/agent-provider';\nimport { registerPending } from \"./brand.mjs\";\n\n// A harness declared in the definition's bundle. Its\n// methods run in the agent's Worker isolate; the session service dials the\n// endpoints they return like any other harness's.\n\ntype EnumInput<E extends string> = E | `${E}`;\n\n// What `describe` may return: what the session service needs to dial and\n// report on the harness. Omitted fields take the defaults of a third-party\n// harness that owns its model and native tools: no base tools, no sandbox\n// wires, harness-owned inference, and none of observe, resume replay, fork or\n// author metadata.\nexport interface AuthoredHarnessDescriptionIface {\n  configSchema: JsonSchema;\n  userInstructionDelivery?: EnumInput<UserInstructionDelivery>;\n  acp: {\n    transports: readonly EnumInput<AcpTransport.Ws | AcpTransport.Http>[];\n    mcp?: readonly EnumInput<McpTransportKind>[];\n  };\n  baseTools?: HarnessDescriptionIface['baseTools'];\n  consumes?: readonly EnumInput<SandboxWire>[];\n  inference?: {\n    vendors?: readonly string[];\n    kinds?: readonly EnumInput<InferenceCredentialKind>[];\n    delivery?: EnumInput<CredentialDelivery>;\n  };\n  supports?: Partial<HarnessDescriptionIface['supports']>;\n  promptWhileRunning?: EnumInput<PromptWhileRunning>;\n  sessionSurvivesDisconnect?: boolean;\n}\n\n// The harness's own session reference; the session service adds which\n// harness it belongs to.\nexport interface AuthoredHarnessSessionRefIface {\n  harnessSessionRef: string;\n  generation: number;\n}\n\nexport type AuthoredHarnessEndpointIface =\n  | {\n      ref: AuthoredHarnessSessionRefIface;\n      transport: EnumInput<AcpTransport.Ws>;\n      url: string;\n      headers?: Record<string, string>;\n      tls?: HarnessClientTlsIface;\n    }\n  | {\n      ref: AuthoredHarnessSessionRefIface;\n      transport: EnumInput<AcpTransport.Http>;\n      url: string;\n      headers?: Record<string, string>;\n      tls?: HarnessClientTlsIface;\n    };\n\nexport interface AuthoredHarnessOpenArgsIface<Config> extends Omit<\n  OpenHarnessSessionArgsIface,\n  'config' | 'observer'\n> {\n  config: Config;\n  // The agent session's id (`session.sessionId`), for keying the harness's own state.\n  sessionId: string;\n}\n\nexport interface AuthoredHarnessResumeArgsIface<\n  Config,\n> extends AuthoredHarnessOpenArgsIface<Config> {\n  ref: HarnessSessionRefIface;\n  lastSeq: number;\n}\n\n// What the session service sends: the open and resume arguments before\n// `sessionId` is filled in from `session`.\nexport type HarnessOpenCallIface<Config> = Omit<AuthoredHarnessOpenArgsIface<Config>, 'sessionId'>;\nexport type HarnessResumeCallIface<Config> = Omit<\n  AuthoredHarnessResumeArgsIface<Config>,\n  'sessionId'\n>;\n\n// park, close and health get the session reference and the definition's\n// secret reader (the isolate's `secrets`, limited to manifest.secrets).\nexport interface AuthoredHarnessRefContextIface {\n  secrets: SecretReaderIface;\n}\n\n// close is graceful unless `force` (the contract's close options).\nexport interface AuthoredHarnessCloseContextIface extends AuthoredHarnessRefContextIface {\n  force: boolean;\n}\n\n// The first argument of park, close and health: the session reference itself,\n// also under `ref`, with the context's fields, so both `park(ref)` and\n// `park({ ref, secrets })` read naturally.\nexport type AuthoredHarnessRefArgIface<Context extends AuthoredHarnessRefContextIface> =\n  HarnessSessionRefIface & Context & { ref: HarnessSessionRefIface };\n\nexport interface AuthoredHarnessHealthIface {\n  ok: boolean;\n  detail?: string;\n  // Defaults to when the check returned.\n  checkedAt?: string;\n}\n\nexport interface AuthoredHarnessIface<Config> {\n  describe(binding?: DescribeHarnessArgsIface): Promise<AuthoredHarnessDescriptionIface>;\n  open(args: AuthoredHarnessOpenArgsIface<Config>): Promise<AuthoredHarnessEndpointIface>;\n  resume(args: AuthoredHarnessResumeArgsIface<Config>): Promise<AuthoredHarnessEndpointIface>;\n  park(\n    ref: AuthoredHarnessRefArgIface<AuthoredHarnessRefContextIface>,\n    ctx: AuthoredHarnessRefContextIface,\n  ): Promise<void>;\n  close(\n    ref: AuthoredHarnessRefArgIface<AuthoredHarnessCloseContextIface>,\n    ctx: AuthoredHarnessCloseContextIface,\n  ): Promise<void>;\n  health(\n    ref: AuthoredHarnessRefArgIface<AuthoredHarnessRefContextIface>,\n    ctx: AuthoredHarnessRefContextIface,\n  ): Promise<AuthoredHarnessHealthIface>;\n}\n\nexport interface DefinedAuthoredHarnessIface<Config> {\n  (config: Config): DefinedHarnessBindingIface;\n  describe(binding?: DescribeHarnessArgsIface): Promise<HarnessDescriptionIface>;\n  open(args: HarnessOpenCallIface<Config>): Promise<AuthoredHarnessEndpointIface>;\n  resume(args: HarnessResumeCallIface<Config>): Promise<AuthoredHarnessEndpointIface>;\n  park(ref: HarnessSessionRefIface, ctx: AuthoredHarnessRefContextIface): Promise<void>;\n  close(ref: HarnessSessionRefIface, ctx: AuthoredHarnessCloseContextIface): Promise<void>;\n  health(\n    ref: HarnessSessionRefIface,\n    ctx: AuthoredHarnessRefContextIface,\n  ): Promise<{ ok: boolean; detail?: string; checkedAt: string }>;\n}\n\n// Fills the omitted description fields (see AuthoredHarnessDescriptionIface)\n// and validates the result against the contract's schema, which also applies\n// its own defaults and turns enum literals into members.\nexport const completeHarnessDescription = (\n  authored: AuthoredHarnessDescriptionIface,\n): HarnessDescriptionIface => {\n  const supports: HarnessDescriptionIface['supports'] = {\n    observe: authored.supports?.observe ?? false,\n    resumeReplay: authored.supports?.resumeReplay ?? false,\n    fork: authored.supports?.fork ?? false,\n    authorMeta: authored.supports?.authorMeta ?? false,\n  };\n  if (authored.supports?.nativeToolPolicy != null)\n    supports.nativeToolPolicy = authored.supports.nativeToolPolicy;\n  return harnessDescriptionSchema.parse({\n    ...authored,\n    acp: { transports: authored.acp.transports, mcp: authored.acp.mcp ?? [] },\n    baseTools: authored.baseTools ?? {},\n    consumes: authored.consumes ?? [],\n    inference: {\n      vendors: authored.inference?.vendors ?? [],\n      kinds: authored.inference?.kinds ?? [InferenceCredentialKind.HarnessOwned],\n      delivery: authored.inference?.delivery ?? CredentialDelivery.AtOpen,\n    },\n    supports,\n  });\n};\n\n// The contract's binding shape, with the bundle export placeholder made\n// unique per harness so the compiler can bind it to a synthesized bundle\n// export even when the harness is not exported.\nexport const defineHarness = <Config extends JsonValue = JsonValue>(\n  implementation: AuthoredHarnessIface<Config>,\n): DefinedAuthoredHarnessIface<Config> => {\n  let placeholder: ProviderRef | null = null;\n  const binding = (config: Config): DefinedHarnessBindingIface => ({\n    harness: placeholder ?? bundleRef('<pending>'),\n    config,\n    definedHarness: true,\n  });\n  const defined = Object.assign(binding, {\n    describe: async (args?: DescribeHarnessArgsIface): Promise<HarnessDescriptionIface> =>\n      completeHarnessDescription(await implementation.describe(args)),\n    open: (args: HarnessOpenCallIface<Config>) =>\n      implementation.open({ ...args, sessionId: args.session.sessionId }),\n    resume: (args: HarnessResumeCallIface<Config>) =>\n      implementation.resume({ ...args, sessionId: args.session.sessionId }),\n    park: (ref: HarnessSessionRefIface, ctx: AuthoredHarnessRefContextIface) =>\n      implementation.park({ ...ref, ...ctx, ref }, ctx),\n    close: (ref: HarnessSessionRefIface, ctx: AuthoredHarnessCloseContextIface) =>\n      implementation.close({ ...ref, ...ctx, ref }, ctx),\n    health: async (ref: HarnessSessionRefIface, ctx: AuthoredHarnessRefContextIface) => {\n      const health = await implementation.health({ ...ref, ...ctx, ref }, ctx);\n      return { ...health, checkedAt: health.checkedAt ?? new Date().toISOString() };\n    },\n  });\n  placeholder = bundleRef(registerPending(defined));\n  return defined;\n};\n"],
+  "mappings": "AAAA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OAgBK;AACP,SAAS,uBAAuB;AAyIzB,MAAM,6BAA6B,CACxC,aAC4B;AAC5B,QAAM,WAAgD;AAAA,IACpD,SAAS,SAAS,UAAU,WAAW;AAAA,IACvC,cAAc,SAAS,UAAU,gBAAgB;AAAA,IACjD,MAAM,SAAS,UAAU,QAAQ;AAAA,IACjC,YAAY,SAAS,UAAU,cAAc;AAAA,EAC/C;AACA,MAAI,SAAS,UAAU,oBAAoB;AACzC,aAAS,mBAAmB,SAAS,SAAS;AAChD,SAAO,yBAAyB,MAAM;AAAA,IACpC,GAAG;AAAA,IACH,KAAK,EAAE,YAAY,SAAS,IAAI,YAAY,KAAK,SAAS,IAAI,OAAO,CAAC,EAAE;AAAA,IACxE,WAAW,SAAS,aAAa,CAAC;AAAA,IAClC,UAAU,SAAS,YAAY,CAAC;AAAA,IAChC,WAAW;AAAA,MACT,SAAS,SAAS,WAAW,WAAW,CAAC;AAAA,MACzC,OAAO,SAAS,WAAW,SAAS,CAAC,wBAAwB,YAAY;AAAA,MACzE,UAAU,SAAS,WAAW,YAAY,mBAAmB;AAAA,IAC/D;AAAA,IACA;AAAA,EACF,CAAC;AACH;AAKO,MAAM,gBAAgB,CAC3B,mBACwC;AACxC,MAAI,cAAkC;AACtC,QAAM,UAAU,CAAC,YAAgD;AAAA,IAC/D,SAAS,eAAe,UAAU,WAAW;AAAA,IAC7C;AAAA,IACA,gBAAgB;AAAA,EAClB;AACA,QAAM,UAAU,OAAO,OAAO,SAAS;AAAA,IACrC,UAAU,OAAO,SACf,2BAA2B,MAAM,eAAe,SAAS,IAAI,CAAC;AAAA,IAChE,MAAM,CAAC,SACL,eAAe,KAAK,EAAE,GAAG,MAAM,WAAW,KAAK,QAAQ,UAAU,CAAC;AAAA,IACpE,QAAQ,CAAC,SACP,eAAe,OAAO,EAAE,GAAG,MAAM,WAAW,KAAK,QAAQ,UAAU,CAAC;AAAA,IACtE,MAAM,CAAC,KAA6B,QAClC,eAAe,KAAK,EAAE,GAAG,KAAK,GAAG,KAAK,IAAI,GAAG,GAAG;AAAA,IAClD,OAAO,CAAC,KAA6B,QACnC,eAAe,MAAM,EAAE,GAAG,KAAK,GAAG,KAAK,IAAI,GAAG,GAAG;AAAA,IACnD,QAAQ,OAAO,KAA6B,QAAwC;AAClF,YAAM,SAAS,MAAM,eAAe,OAAO,EAAE,GAAG,KAAK,GAAG,KAAK,IAAI,GAAG,GAAG;AACvE,aAAO,EAAE,GAAG,QAAQ,WAAW,OAAO,cAAa,oBAAI,KAAK,GAAE,YAAY,EAAE;AAAA,IAC9E;AAAA,EACF,CAAC;AACD,gBAAc,UAAU,gBAAgB,OAAO,CAAC;AAChD,SAAO;AACT;",
+  "names": []
+}

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

@@ -0,0 +1,120 @@
+import type { JsonValue, NetworkSandboxSessionIface } from '@finalai/agent-provider';
+import { type AuthoredValue } from "../runtime/values.mjs";
+import type { AgentSessionInfoIface, FinalPlatformClientIface, SecretsIface, TranscriptMessageIface } from "./context.mjs";
+import type { ToolCallEventDataIface } from "./tools.mjs";
+export { toolResultFrom } from "./tools.mjs";
+export declare enum HookEvent {
+    SessionOpened = "session.opened",
+    TurnStarted = "turn.started",
+    TurnEnded = "turn.ended",
+    UserMessageChunk = "user_message_chunk",
+    AgentMessageChunk = "agent_message_chunk",
+    AgentMessage = "agent_message",
+    AgentThoughtChunk = "agent_thought_chunk",
+    ToolCall = "tool_call",
+    ToolCallUpdate = "tool_call_update",
+    ToolCallContentChunk = "tool_call_content_chunk",
+    Plan = "plan",
+    PendingCreated = "pending.created",
+    PendingResolved = "pending.resolved",
+    StateUpdate = "state_update",
+    SessionFailed = "session.failed",
+    SessionClosed = "session.closed",
+    CompactionUpdate = "compaction_update",
+    UsageUpdate = "usage_update",
+    AvailableCommandsUpdate = "available_commands_update",
+    CurrentModeUpdate = "current_mode_update",
+    ConfigOptionUpdate = "config_option_update",
+    SessionInfoUpdate = "session_info_update",
+    Notice = "notice"
+}
+export declare const HOOK_WILDCARD = "*";
+export declare enum HookEventKeyKind {
+    Canonical = "canonical",
+    Wildcard = "wildcard",
+    Unknown = "unknown"
+}
+export interface NormalizedHookKeyIface {
+    key: string;
+    kind: HookEventKeyKind;
+    events: string[];
+}
+export declare const normalizeHookKey: (key: string) => NormalizedHookKeyIface;
+export interface HookEventMetaIface {
+    id: string;
+    at: string;
+    seq: number;
+}
+export interface HookEventIface<TType extends string = string, TData = AuthoredValue> {
+    type: TType;
+    data: TData;
+    meta: HookEventMetaIface;
+}
+export interface HookEventDataMapIface {
+    'session.opened': {
+        sessionId: string;
+    };
+    'turn.started': {
+        turnId: string;
+        promptMessageId: string | null;
+        authorParticipantId: string | null;
+    };
+    'turn.ended': {
+        turnId: string;
+        stopReason: string | null;
+    };
+    tool_call: ToolCallEventDataIface;
+    tool_call_update: ToolCallEventDataIface;
+    tool_call_content_chunk: ToolCallEventDataIface;
+    'pending.created': {
+        pendingId: string;
+        kind: 'permission' | 'elicitation' | 'authorization';
+        request: JsonValue;
+    };
+    'pending.resolved': {
+        pendingId: string;
+        outcome: JsonValue;
+    };
+    'session.failed': {
+        reason: string | null;
+    };
+    'session.closed': {
+        reason: string | null;
+    };
+}
+type CanonicalData<TKey extends string> = TKey extends keyof HookEventDataMapIface ? HookEventDataMapIface[TKey] : Record<string, JsonValue>;
+export type HookEventKey = `${HookEvent}` | typeof HOOK_WILDCARD | `_final/${string}`;
+export type HookEventFor<TKey extends string> = TKey extends typeof HOOK_WILDCARD ? HookEventIface : HookEventIface<TKey, CanonicalData<TKey>>;
+export interface HookSessionInfoIface extends AgentSessionInfoIface {
+    readonly messages: readonly TranscriptMessageIface[];
+}
+export interface HookContextIface {
+    readonly session: HookSessionInfoIface;
+    readonly agent: {
+        readonly definitionId: string;
+        readonly name: string;
+        readonly revisionId: string;
+    };
+    readonly channel: {
+        readonly kind: string | null;
+    };
+    getSandbox(target?: string): Promise<NetworkSandboxSessionIface>;
+    cancel(): void;
+    readonly secrets: SecretsIface;
+    readonly final: FinalPlatformClientIface;
+}
+export type HookHandler<TKey extends string> = (event: HookEventFor<TKey>, ctx: HookContextIface) => void | Promise<void>;
+export type HookHandlersIface = {
+    readonly [TKey in HookEventKey]?: HookHandler<TKey>;
+};
+export interface HookDefinitionIface {
+    readonly events?: HookHandlersIface;
+}
+export declare const defineHook: (definition: HookDefinitionIface) => HookDefinitionIface;
+export interface HookDispatchEventIface {
+    type: string;
+    data: AuthoredValue;
+    meta: HookEventMetaIface;
+}
+export type HookInvocable = (event: HookDispatchEventIface, ctx: HookContextIface) => AuthoredValue;
+export declare const hookHandlersFor: (hook: AuthoredValue, event: HookDispatchEventIface) => HookInvocable[];

package/dist/modules/authoring/hooks.mjs

@@ -0,0 +1,72 @@
+import * as z from "zod";
+import { authoredRecordSchema, isCallable } from "../runtime/values.mjs";
+import { AuthoredKind, stamp } from "./brand.mjs";
+import { toolResultFrom } from "./tools.mjs";
+var HookEvent = /* @__PURE__ */ ((HookEvent2) => {
+  HookEvent2["SessionOpened"] = "session.opened";
+  HookEvent2["TurnStarted"] = "turn.started";
+  HookEvent2["TurnEnded"] = "turn.ended";
+  HookEvent2["UserMessageChunk"] = "user_message_chunk";
+  HookEvent2["AgentMessageChunk"] = "agent_message_chunk";
+  HookEvent2["AgentMessage"] = "agent_message";
+  HookEvent2["AgentThoughtChunk"] = "agent_thought_chunk";
+  HookEvent2["ToolCall"] = "tool_call";
+  HookEvent2["ToolCallUpdate"] = "tool_call_update";
+  HookEvent2["ToolCallContentChunk"] = "tool_call_content_chunk";
+  HookEvent2["Plan"] = "plan";
+  HookEvent2["PendingCreated"] = "pending.created";
+  HookEvent2["PendingResolved"] = "pending.resolved";
+  HookEvent2["StateUpdate"] = "state_update";
+  HookEvent2["SessionFailed"] = "session.failed";
+  HookEvent2["SessionClosed"] = "session.closed";
+  HookEvent2["CompactionUpdate"] = "compaction_update";
+  HookEvent2["UsageUpdate"] = "usage_update";
+  HookEvent2["AvailableCommandsUpdate"] = "available_commands_update";
+  HookEvent2["CurrentModeUpdate"] = "current_mode_update";
+  HookEvent2["ConfigOptionUpdate"] = "config_option_update";
+  HookEvent2["SessionInfoUpdate"] = "session_info_update";
+  HookEvent2["Notice"] = "notice";
+  return HookEvent2;
+})(HookEvent || {});
+const HOOK_WILDCARD = "*";
+const CANONICAL_EVENTS = new Set(Object.values(HookEvent));
+var HookEventKeyKind = /* @__PURE__ */ ((HookEventKeyKind2) => {
+  HookEventKeyKind2["Canonical"] = "canonical";
+  HookEventKeyKind2["Wildcard"] = "wildcard";
+  HookEventKeyKind2["Unknown"] = "unknown";
+  return HookEventKeyKind2;
+})(HookEventKeyKind || {});
+const normalizeHookKey = (key) => {
+  if (key === HOOK_WILDCARD)
+    return { key, kind: "wildcard" /* Wildcard */, events: [HOOK_WILDCARD] };
+  if (CANONICAL_EVENTS.has(key) || key.startsWith("_final/")) {
+    return { key, kind: "canonical" /* Canonical */, events: [key] };
+  }
+  return { key, kind: "unknown" /* Unknown */, events: [] };
+};
+const defineHook = (definition) => stamp({ ...definition }, AuthoredKind.Hook);
+const keyMatches = (key, event) => key === event.type && (CANONICAL_EVENTS.has(key) || key.startsWith("_final/"));
+const hookEventsSchema = z.looseObject({ events: authoredRecordSchema });
+const hookHandlersFor = (hook, event) => {
+  const parsed = hookEventsSchema.safeParse(hook);
+  if (!parsed.success) return [];
+  const typed = [];
+  let wildcard = null;
+  for (const [key, handler] of Object.entries(parsed.data.events)) {
+    if (!isCallable(handler)) continue;
+    const invoke = (dispatched, ctx) => handler(dispatched, ctx);
+    if (key === HOOK_WILDCARD) wildcard = invoke;
+    else if (keyMatches(key, event)) typed.push(invoke);
+  }
+  return wildcard == null ? typed : [...typed, wildcard];
+};
+export {
+  HOOK_WILDCARD,
+  HookEvent,
+  HookEventKeyKind,
+  defineHook,
+  hookHandlersFor,
+  normalizeHookKey,
+  toolResultFrom
+};
+//# sourceMappingURL=hooks.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/authoring/hooks.ts"],
+  "sourcesContent": ["import type { JsonValue, NetworkSandboxSessionIface } from '@finalai/agent-provider';\nimport * as z from 'zod';\nimport { authoredRecordSchema, isCallable, type AuthoredValue } from \"../runtime/values.mjs\";\nimport { AuthoredKind, stamp } from \"./brand.mjs\";\nimport type {\n  AgentSessionInfoIface,\n  FinalPlatformClientIface,\n  SecretsIface,\n  TranscriptMessageIface,\n} from \"./context.mjs\";\nimport type { ToolCallEventDataIface } from \"./tools.mjs\";\n\nexport { toolResultFrom } from \"./tools.mjs\";\n\n// Observe-only subscribers to the session's ACP log. Event\n// names are ACP update kinds and request methods plus a few session-service\n// lifecycle events. Only these canonical names are accepted.\n\nexport enum HookEvent {\n  SessionOpened = 'session.opened',\n  TurnStarted = 'turn.started',\n  TurnEnded = 'turn.ended',\n  UserMessageChunk = 'user_message_chunk',\n  AgentMessageChunk = 'agent_message_chunk',\n  AgentMessage = 'agent_message',\n  AgentThoughtChunk = 'agent_thought_chunk',\n  ToolCall = 'tool_call',\n  ToolCallUpdate = 'tool_call_update',\n  ToolCallContentChunk = 'tool_call_content_chunk',\n  Plan = 'plan',\n  PendingCreated = 'pending.created',\n  PendingResolved = 'pending.resolved',\n  StateUpdate = 'state_update',\n  SessionFailed = 'session.failed',\n  SessionClosed = 'session.closed',\n  CompactionUpdate = 'compaction_update',\n  UsageUpdate = 'usage_update',\n  AvailableCommandsUpdate = 'available_commands_update',\n  CurrentModeUpdate = 'current_mode_update',\n  ConfigOptionUpdate = 'config_option_update',\n  SessionInfoUpdate = 'session_info_update',\n  Notice = 'notice',\n}\n\nexport const HOOK_WILDCARD = '*';\n\nconst CANONICAL_EVENTS: ReadonlySet<string> = new Set(Object.values(HookEvent));\n\nexport enum HookEventKeyKind {\n  Canonical = 'canonical',\n  Wildcard = 'wildcard',\n  Unknown = 'unknown',\n}\n\nexport interface NormalizedHookKeyIface {\n  key: string;\n  kind: HookEventKeyKind;\n  // Canonical event names this key subscribes to ('*' for the wildcard).\n  events: string[];\n}\n\nexport const normalizeHookKey = (key: string): NormalizedHookKeyIface => {\n  if (key === HOOK_WILDCARD)\n    return { key, kind: HookEventKeyKind.Wildcard, events: [HOOK_WILDCARD] };\n  if (CANONICAL_EVENTS.has(key) || key.startsWith('_final/')) {\n    return { key, kind: HookEventKeyKind.Canonical, events: [key] };\n  }\n  return { key, kind: HookEventKeyKind.Unknown, events: [] };\n};\n\nexport interface HookEventMetaIface {\n  // '<sessionId>:<seq>' with the session's wire id (`ases_\u2026:12`): sortable\n  // within a session and stable across redelivery.\n  id: string;\n  at: string;\n  seq: number;\n}\n\nexport interface HookEventIface<TType extends string = string, TData = AuthoredValue> {\n  type: TType;\n  data: TData;\n  meta: HookEventMetaIface;\n}\n\n// Lifecycle event data names platform objects by their wire ids, as the public\n// API does: sessions `ases_\u2026`, turns `atrn_\u2026`, participants `cpart_\u2026`, pending\n// requests `apnd_\u2026`. `promptMessageId` is the harness's ACP message id. ACP\n// update events (tool_call, agent_message_chunk, \u2026) carry the ACP payload as is.\nexport interface HookEventDataMapIface {\n  'session.opened': { sessionId: string };\n  'turn.started': {\n    turnId: string;\n    promptMessageId: string | null;\n    authorParticipantId: string | null;\n  };\n  'turn.ended': { turnId: string; stopReason: string | null };\n  tool_call: ToolCallEventDataIface;\n  tool_call_update: ToolCallEventDataIface;\n  tool_call_content_chunk: ToolCallEventDataIface;\n  'pending.created': {\n    pendingId: string;\n    kind: 'permission' | 'elicitation' | 'authorization';\n    request: JsonValue;\n  };\n  'pending.resolved': { pendingId: string; outcome: JsonValue };\n  'session.failed': { reason: string | null };\n  'session.closed': { reason: string | null };\n}\n\ntype CanonicalData<TKey extends string> = TKey extends keyof HookEventDataMapIface\n  ? HookEventDataMapIface[TKey]\n  : Record<string, JsonValue>;\n\nexport type HookEventKey = `${HookEvent}` | typeof HOOK_WILDCARD | `_final/${string}`;\n\nexport type HookEventFor<TKey extends string> = TKey extends typeof HOOK_WILDCARD\n  ? HookEventIface\n  : HookEventIface<TKey, CanonicalData<TKey>>;\n\nexport interface HookSessionInfoIface extends AgentSessionInfoIface {\n  readonly messages: readonly TranscriptMessageIface[];\n}\n\nexport interface HookContextIface {\n  readonly session: HookSessionInfoIface;\n  readonly agent: {\n    readonly definitionId: string;\n    readonly name: string;\n    readonly revisionId: string;\n  };\n  readonly channel: { readonly kind: string | null };\n  getSandbox(target?: string): Promise<NetworkSandboxSessionIface>;\n  // Sends session/cancel for the running turn.\n  cancel(): void;\n  readonly secrets: SecretsIface;\n  readonly final: FinalPlatformClientIface;\n}\n\nexport type HookHandler<TKey extends string> = (\n  event: HookEventFor<TKey>,\n  ctx: HookContextIface,\n) => void | Promise<void>;\n\nexport type HookHandlersIface = { readonly [TKey in HookEventKey]?: HookHandler<TKey> };\n\nexport interface HookDefinitionIface {\n  readonly events?: HookHandlersIface;\n}\n\nexport const defineHook = (definition: HookDefinitionIface): HookDefinitionIface =>\n  stamp({ ...definition }, AuthoredKind.Hook);\n\nexport interface HookDispatchEventIface {\n  type: string;\n  data: AuthoredValue;\n  meta: HookEventMetaIface;\n}\n\nconst keyMatches = (key: string, event: HookDispatchEventIface): boolean =>\n  key === event.type && (CANONICAL_EVENTS.has(key) || key.startsWith('_final/'));\n\nexport type HookInvocable = (event: HookDispatchEventIface, ctx: HookContextIface) => AuthoredValue;\n\nconst hookEventsSchema = z.looseObject({ events: authoredRecordSchema });\n\n// Handlers for one event: typed handlers in declaration order, then the\n// wildcard.\nexport const hookHandlersFor = (\n  hook: AuthoredValue,\n  event: HookDispatchEventIface,\n): HookInvocable[] => {\n  const parsed = hookEventsSchema.safeParse(hook);\n  if (!parsed.success) return [];\n  const typed: HookInvocable[] = [];\n  let wildcard: HookInvocable | null = null;\n  for (const [key, handler] of Object.entries(parsed.data.events)) {\n    if (!isCallable(handler)) continue;\n    const invoke: HookInvocable = (dispatched, ctx) => handler(dispatched, ctx);\n    if (key === HOOK_WILDCARD) wildcard = invoke;\n    else if (keyMatches(key, event)) typed.push(invoke);\n  }\n  return wildcard == null ? typed : [...typed, wildcard];\n};\n"],
+  "mappings": "AACA,YAAY,OAAO;AACnB,SAAS,sBAAsB,kBAAsC;AACrE,SAAS,cAAc,aAAa;AASpC,SAAS,sBAAsB;AAMxB,IAAK,YAAL,kBAAKA,eAAL;AACL,EAAAA,WAAA,mBAAgB;AAChB,EAAAA,WAAA,iBAAc;AACd,EAAAA,WAAA,eAAY;AACZ,EAAAA,WAAA,sBAAmB;AACnB,EAAAA,WAAA,uBAAoB;AACpB,EAAAA,WAAA,kBAAe;AACf,EAAAA,WAAA,uBAAoB;AACpB,EAAAA,WAAA,cAAW;AACX,EAAAA,WAAA,oBAAiB;AACjB,EAAAA,WAAA,0BAAuB;AACvB,EAAAA,WAAA,UAAO;AACP,EAAAA,WAAA,oBAAiB;AACjB,EAAAA,WAAA,qBAAkB;AAClB,EAAAA,WAAA,iBAAc;AACd,EAAAA,WAAA,mBAAgB;AAChB,EAAAA,WAAA,mBAAgB;AAChB,EAAAA,WAAA,sBAAmB;AACnB,EAAAA,WAAA,iBAAc;AACd,EAAAA,WAAA,6BAA0B;AAC1B,EAAAA,WAAA,uBAAoB;AACpB,EAAAA,WAAA,wBAAqB;AACrB,EAAAA,WAAA,uBAAoB;AACpB,EAAAA,WAAA,YAAS;AAvBC,SAAAA;AAAA,GAAA;AA0BL,MAAM,gBAAgB;AAE7B,MAAM,mBAAwC,IAAI,IAAI,OAAO,OAAO,SAAS,CAAC;AAEvE,IAAK,mBAAL,kBAAKC,sBAAL;AACL,EAAAA,kBAAA,eAAY;AACZ,EAAAA,kBAAA,cAAW;AACX,EAAAA,kBAAA,aAAU;AAHA,SAAAA;AAAA,GAAA;AAaL,MAAM,mBAAmB,CAAC,QAAwC;AACvE,MAAI,QAAQ;AACV,WAAO,EAAE,KAAK,MAAM,2BAA2B,QAAQ,CAAC,aAAa,EAAE;AACzE,MAAI,iBAAiB,IAAI,GAAG,KAAK,IAAI,WAAW,SAAS,GAAG;AAC1D,WAAO,EAAE,KAAK,MAAM,6BAA4B,QAAQ,CAAC,GAAG,EAAE;AAAA,EAChE;AACA,SAAO,EAAE,KAAK,MAAM,yBAA0B,QAAQ,CAAC,EAAE;AAC3D;AAiFO,MAAM,aAAa,CAAC,eACzB,MAAM,EAAE,GAAG,WAAW,GAAG,aAAa,IAAI;AAQ5C,MAAM,aAAa,CAAC,KAAa,UAC/B,QAAQ,MAAM,SAAS,iBAAiB,IAAI,GAAG,KAAK,IAAI,WAAW,SAAS;AAI9E,MAAM,mBAAmB,EAAE,YAAY,EAAE,QAAQ,qBAAqB,CAAC;AAIhE,MAAM,kBAAkB,CAC7B,MACA,UACoB;AACpB,QAAM,SAAS,iBAAiB,UAAU,IAAI;AAC9C,MAAI,CAAC,OAAO,QAAS,QAAO,CAAC;AAC7B,QAAM,QAAyB,CAAC;AAChC,MAAI,WAAiC;AACrC,aAAW,CAAC,KAAK,OAAO,KAAK,OAAO,QAAQ,OAAO,KAAK,MAAM,GAAG;AAC/D,QAAI,CAAC,WAAW,OAAO,EAAG;AAC1B,UAAM,SAAwB,CAAC,YAAY,QAAQ,QAAQ,YAAY,GAAG;AAC1E,QAAI,QAAQ,cAAe,YAAW;AAAA,aAC7B,WAAW,KAAK,KAAK,EAAG,OAAM,KAAK,MAAM;AAAA,EACpD;AACA,SAAO,YAAY,OAAO,QAAQ,CAAC,GAAG,OAAO,QAAQ;AACvD;",
+  "names": ["HookEvent", "HookEventKeyKind"]
+}

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

@@ -0,0 +1,27 @@
+export { defineAgent } from "./agent.mjs";
+export type { AgentDefinitionInputIface, ChannelBindingValueIface, HarnessBindingValueIface, } from "./agent.mjs";
+export { always, never, whenInput } from "./approval.mjs";
+export type { ApprovalPolicyIface } from "./approval.mjs";
+export { DELETE, GET, POST, PUT, WS, defineChannel, defineProviderChannel, disableChannel, } from "./channels.mjs";
+export type { AuthoredChannelDefinitionIface, RouteHandler, RouteHandlerArgsIface, } from "./channels.mjs";
+export { defineMcpClientConnection } from "./connections.mjs";
+export type { McpClientConnectionDefinitionIface, McpConnectionAuthIface } from "./connections.mjs";
+export * from "./context.mjs";
+export { CredentialOwner, CredentialPayer, credentials } from "./credentials.mjs";
+export type { CredentialNode, CredentialPolicyIface } from "./credentials.mjs";
+export { defineDynamic } from "./dynamic.mjs";
+export type { DynamicDefinitionIface, DynamicEventsIface, DynamicSentinelIface } from "./dynamic.mjs";
+export { completeHarnessDescription, defineHarness } from "./harness.mjs";
+export type { AuthoredHarnessCloseContextIface, AuthoredHarnessDescriptionIface, AuthoredHarnessEndpointIface, AuthoredHarnessHealthIface, AuthoredHarnessIface, AuthoredHarnessOpenArgsIface, AuthoredHarnessRefContextIface, AuthoredHarnessResumeArgsIface, AuthoredHarnessSessionRefIface, DefinedAuthoredHarnessIface, } from "./harness.mjs";
+export { HookEvent, defineHook } from "./hooks.mjs";
+export type { HookContextIface, HookDefinitionIface, HookEventFor, HookEventIface, HookEventKey, } from "./hooks.mjs";
+export { defineInstructions } from "./instructions.mjs";
+export type { DefinedInstructionsIface, InstructionsDefinitionIface } from "./instructions.mjs";
+export { SandboxWire, baseTools, defineSandbox, defineSandboxProvider, harnessHost, } from "./sandbox.mjs";
+export type { BaseToolsValueIface, HarnessHostIface, SandboxSelector, SandboxSelectorContextIface, SandboxTargetValue, } from "./sandbox.mjs";
+export { defineSchedule } from "./schedules.mjs";
+export type { ScheduleInputIface } from "./schedules.mjs";
+export { defineSkill } from "./skills.mjs";
+export type { SkillDefinitionIface } from "./skills.mjs";
+export { defineTool, toolResultFrom } from "./tools.mjs";
+export type { DefinedToolIface, StandardSchemaLikeIface, ToolCallEventDataIface, ToolDefinitionIface, ToolInputSchema, } from "./tools.mjs";

package/dist/modules/authoring/index.mjs

@@ -0,0 +1,63 @@
+import { defineAgent } from "./agent.mjs";
+import { always, never, whenInput } from "./approval.mjs";
+import {
+  DELETE,
+  GET,
+  POST,
+  PUT,
+  WS,
+  defineChannel,
+  defineProviderChannel,
+  disableChannel
+} from "./channels.mjs";
+import { defineMcpClientConnection } from "./connections.mjs";
+export * from "./context.mjs";
+import { CredentialOwner, CredentialPayer, credentials } from "./credentials.mjs";
+import { defineDynamic } from "./dynamic.mjs";
+import { completeHarnessDescription, defineHarness } from "./harness.mjs";
+import { HookEvent, defineHook } from "./hooks.mjs";
+import { defineInstructions } from "./instructions.mjs";
+import {
+  SandboxWire,
+  baseTools,
+  defineSandbox,
+  defineSandboxProvider,
+  harnessHost
+} from "./sandbox.mjs";
+import { defineSchedule } from "./schedules.mjs";
+import { defineSkill } from "./skills.mjs";
+import { defineTool, toolResultFrom } from "./tools.mjs";
+export {
+  CredentialOwner,
+  CredentialPayer,
+  DELETE,
+  GET,
+  HookEvent,
+  POST,
+  PUT,
+  SandboxWire,
+  WS,
+  always,
+  baseTools,
+  completeHarnessDescription,
+  credentials,
+  defineAgent,
+  defineChannel,
+  defineDynamic,
+  defineHarness,
+  defineHook,
+  defineInstructions,
+  defineMcpClientConnection,
+  defineProviderChannel,
+  defineSandbox,
+  defineSandboxProvider,
+  defineSchedule,
+  defineSkill,
+  defineTool,
+  disableChannel,
+  harnessHost,
+  never,
+  toolResultFrom,
+  whenInput
+};
+//# sourceMappingURL=index.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/authoring/index.ts"],
+  "sourcesContent": ["export { defineAgent } from \"./agent.mjs\";\nexport type {\n  AgentDefinitionInputIface,\n  ChannelBindingValueIface,\n  HarnessBindingValueIface,\n} from \"./agent.mjs\";\nexport { always, never, whenInput } from \"./approval.mjs\";\nexport type { ApprovalPolicyIface } from \"./approval.mjs\";\nexport {\n  DELETE,\n  GET,\n  POST,\n  PUT,\n  WS,\n  defineChannel,\n  defineProviderChannel,\n  disableChannel,\n} from \"./channels.mjs\";\nexport type {\n  AuthoredChannelDefinitionIface,\n  RouteHandler,\n  RouteHandlerArgsIface,\n} from \"./channels.mjs\";\nexport { defineMcpClientConnection } from \"./connections.mjs\";\nexport type { McpClientConnectionDefinitionIface, McpConnectionAuthIface } from \"./connections.mjs\";\nexport * from \"./context.mjs\";\nexport { CredentialOwner, CredentialPayer, credentials } from \"./credentials.mjs\";\nexport type { CredentialNode, CredentialPolicyIface } from \"./credentials.mjs\";\nexport { defineDynamic } from \"./dynamic.mjs\";\nexport type { DynamicDefinitionIface, DynamicEventsIface, DynamicSentinelIface } from \"./dynamic.mjs\";\nexport { completeHarnessDescription, defineHarness } from \"./harness.mjs\";\nexport type {\n  AuthoredHarnessCloseContextIface,\n  AuthoredHarnessDescriptionIface,\n  AuthoredHarnessEndpointIface,\n  AuthoredHarnessHealthIface,\n  AuthoredHarnessIface,\n  AuthoredHarnessOpenArgsIface,\n  AuthoredHarnessRefContextIface,\n  AuthoredHarnessResumeArgsIface,\n  AuthoredHarnessSessionRefIface,\n  DefinedAuthoredHarnessIface,\n} from \"./harness.mjs\";\nexport { HookEvent, defineHook } from \"./hooks.mjs\";\nexport type {\n  HookContextIface,\n  HookDefinitionIface,\n  HookEventFor,\n  HookEventIface,\n  HookEventKey,\n} from \"./hooks.mjs\";\nexport { defineInstructions } from \"./instructions.mjs\";\nexport type { DefinedInstructionsIface, InstructionsDefinitionIface } from \"./instructions.mjs\";\nexport {\n  SandboxWire,\n  baseTools,\n  defineSandbox,\n  defineSandboxProvider,\n  harnessHost,\n} from \"./sandbox.mjs\";\nexport type {\n  BaseToolsValueIface,\n  HarnessHostIface,\n  SandboxSelector,\n  SandboxSelectorContextIface,\n  SandboxTargetValue,\n} from \"./sandbox.mjs\";\nexport { defineSchedule } from \"./schedules.mjs\";\nexport type { ScheduleInputIface } from \"./schedules.mjs\";\nexport { defineSkill } from \"./skills.mjs\";\nexport type { SkillDefinitionIface } from \"./skills.mjs\";\nexport { defineTool, toolResultFrom } from \"./tools.mjs\";\nexport type {\n  DefinedToolIface,\n  StandardSchemaLikeIface,\n  ToolCallEventDataIface,\n  ToolDefinitionIface,\n  ToolInputSchema,\n} from \"./tools.mjs\";\n"],
+  "mappings": "AAAA,SAAS,mBAAmB;AAM5B,SAAS,QAAQ,OAAO,iBAAiB;AAEzC;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAMP,SAAS,iCAAiC;AAE1C,cAAc;AACd,SAAS,iBAAiB,iBAAiB,mBAAmB;AAE9D,SAAS,qBAAqB;AAE9B,SAAS,4BAA4B,qBAAqB;AAa1D,SAAS,WAAW,kBAAkB;AAQtC,SAAS,0BAA0B;AAEnC;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAQP,SAAS,sBAAsB;AAE/B,SAAS,mBAAmB;AAE5B,SAAS,YAAY,sBAAsB;",
+  "names": []
+}

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

@@ -0,0 +1,13 @@
+import { InstructionRole } from '@finalai/agent-provider';
+export type { DynamicResolveContextIface } from "./context.mjs";
+export { defineDynamic } from "./dynamic.mjs";
+export type { DynamicDefinitionIface, DynamicSentinelIface } from "./dynamic.mjs";
+export interface InstructionsDefinitionIface {
+    readonly content: string;
+    readonly role?: InstructionRole | `${InstructionRole}`;
+}
+export interface DefinedInstructionsIface {
+    readonly content: string;
+    readonly role: InstructionRole;
+}
+export declare const defineInstructions: (definition: InstructionsDefinitionIface) => DefinedInstructionsIface;

package/dist/modules/authoring/instructions.mjs

@@ -0,0 +1,15 @@
+import { InstructionRole } from "@finalai/agent-provider";
+import { AuthoredKind, stamp } from "./brand.mjs";
+import { defineDynamic } from "./dynamic.mjs";
+const defineInstructions = (definition) => stamp(
+  {
+    content: definition.content,
+    role: definition.role === InstructionRole.User ? InstructionRole.User : InstructionRole.System
+  },
+  AuthoredKind.Instructions
+);
+export {
+  defineDynamic,
+  defineInstructions
+};
+//# sourceMappingURL=instructions.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/authoring/instructions.ts"],
+  "sourcesContent": ["import { InstructionRole } from '@finalai/agent-provider';\nimport { AuthoredKind, stamp } from \"./brand.mjs\";\n\nexport type { DynamicResolveContextIface } from \"./context.mjs\";\nexport { defineDynamic } from \"./dynamic.mjs\";\nexport type { DynamicDefinitionIface, DynamicSentinelIface } from \"./dynamic.mjs\";\n\n// defineInstructions: one fragment of `harness.config.instructions`.\n// Omitted `role` defaults to system.\nexport interface InstructionsDefinitionIface {\n  readonly content: string;\n  readonly role?: InstructionRole | `${InstructionRole}`;\n}\n\nexport interface DefinedInstructionsIface {\n  readonly content: string;\n  readonly role: InstructionRole;\n}\n\nexport const defineInstructions = (\n  definition: InstructionsDefinitionIface,\n): DefinedInstructionsIface =>\n  stamp(\n    {\n      content: definition.content,\n      role:\n        definition.role === InstructionRole.User ? InstructionRole.User : InstructionRole.System,\n    },\n    AuthoredKind.Instructions,\n  );\n"],
+  "mappings": "AAAA,SAAS,uBAAuB;AAChC,SAAS,cAAc,aAAa;AAGpC,SAAS,qBAAqB;AAevB,MAAM,qBAAqB,CAChC,eAEA;AAAA,EACE;AAAA,IACE,SAAS,WAAW;AAAA,IACpB,MACE,WAAW,SAAS,gBAAgB,OAAO,gBAAgB,OAAO,gBAAgB;AAAA,EACtF;AAAA,EACA,aAAa;AACf;",
+  "names": []
+}

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

@@ -0,0 +1,21 @@
+import type { BaseCapability, NetworkSandboxSessionIface, SandboxEnvironmentIface, SandboxOpenRequestIface } from '@finalai/agent-provider';
+import type { AgentSessionInfoIface, SecretsIface } from "./context.mjs";
+import type { DynamicSentinelIface } from "./dynamic.mjs";
+export { defineSandboxProvider, SandboxWire } from '@finalai/agent-provider';
+export interface SandboxSelectorContextIface {
+    readonly session: AgentSessionInfoIface;
+    readonly secrets: SecretsIface;
+    open(request: SandboxOpenRequestIface<unknown, unknown>): Promise<NetworkSandboxSessionIface>;
+}
+export type SandboxSelector = (ctx: SandboxSelectorContextIface) => NetworkSandboxSessionIface | SandboxOpenRequestIface<unknown, unknown> | Promise<NetworkSandboxSessionIface | SandboxOpenRequestIface<unknown, unknown>>;
+export interface HarnessHostIface {
+    readonly harnessHost: true;
+}
+export declare const harnessHost: HarnessHostIface;
+export type SandboxTargetValue = HarnessHostIface | SandboxEnvironmentIface<unknown, unknown> | SandboxOpenRequestIface<unknown, unknown> | DynamicSentinelIface | SandboxSelector | string;
+export declare const defineSandbox: <T extends SandboxSelector | SandboxEnvironmentIface<unknown, unknown>>(value: T) => T;
+export type BaseToolsInputIface = Partial<Record<BaseCapability | `${BaseCapability}`, SandboxTargetValue>>;
+export interface BaseToolsValueIface {
+    readonly base: BaseToolsInputIface;
+}
+export declare const baseTools: (base: BaseToolsInputIface) => BaseToolsValueIface;

package/dist/modules/authoring/sandbox.mjs

@@ -0,0 +1,13 @@
+import { AuthoredKind, stamp } from "./brand.mjs";
+import { defineSandboxProvider, SandboxWire } from "@finalai/agent-provider";
+const harnessHost = stamp({ harnessHost: true }, AuthoredKind.HarnessHost);
+const defineSandbox = (value) => value instanceof Function ? stamp(value, AuthoredKind.SandboxSelector) : value;
+const baseTools = (base) => stamp({ base: { ...base } }, AuthoredKind.BaseTools);
+export {
+  SandboxWire,
+  baseTools,
+  defineSandbox,
+  defineSandboxProvider,
+  harnessHost
+};
+//# sourceMappingURL=sandbox.mjs.map