@finalai/agent-definition 0.1.0

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/authoring/sandbox.ts"],
+  "sourcesContent": ["import type {\n  BaseCapability,\n  NetworkSandboxSessionIface,\n  SandboxEnvironmentIface,\n  SandboxOpenRequestIface,\n} from '@finalai/agent-provider';\nimport { AuthoredKind, stamp } from \"./brand.mjs\";\nimport type { AgentSessionInfoIface, SecretsIface } from \"./context.mjs\";\nimport type { DynamicSentinelIface } from \"./dynamic.mjs\";\n\nexport { defineSandboxProvider, SandboxWire } from '@finalai/agent-provider';\n\n// sandbox.ts: named exports are sandbox targets (an\n// environment such as `computerSetupGuide({...})`, or a defineDynamic resolving\n// to one); the default export is the default target, either an environment\n// or a selector that opens it per session.\n\nexport interface SandboxSelectorContextIface {\n  readonly session: AgentSessionInfoIface;\n  readonly secrets: SecretsIface;\n  // Starts (or reattaches to) the requested environment and returns the live\n  // session, so a selector can prepare it before the agent uses it.\n  open(request: SandboxOpenRequestIface<unknown, unknown>): Promise<NetworkSandboxSessionIface>;\n}\n\nexport type SandboxSelector = (\n  ctx: SandboxSelectorContextIface,\n) =>\n  | NetworkSandboxSessionIface\n  | SandboxOpenRequestIface<unknown, unknown>\n  | Promise<NetworkSandboxSessionIface | SandboxOpenRequestIface<unknown, unknown>>;\n\n// The harness's own host as a base-tool binding: the capability is the\n// harness's native one where it runs, with no sandbox target. Only\n// harnesses that provide it natively (host-disableable, host-fixed) can serve it.\nexport interface HarnessHostIface {\n  readonly harnessHost: true;\n}\n\nexport const harnessHost: HarnessHostIface = stamp({ harnessHost: true }, AuthoredKind.HarnessHost);\n\nexport type SandboxTargetValue =\n  | HarnessHostIface\n  | SandboxEnvironmentIface<unknown, unknown>\n  | SandboxOpenRequestIface<unknown, unknown>\n  | DynamicSentinelIface\n  | SandboxSelector\n  // A target name, for targets that are not imported (Build forms).\n  | string;\n\nexport const defineSandbox = <\n  T extends SandboxSelector | SandboxEnvironmentIface<unknown, unknown>,\n>(\n  value: T,\n): T => (value instanceof Function ? stamp(value, AuthoredKind.SandboxSelector) : value);\n\nexport type BaseToolsInputIface = Partial<\n  Record<BaseCapability | `${BaseCapability}`, SandboxTargetValue>\n>;\n\nexport interface BaseToolsValueIface {\n  readonly base: BaseToolsInputIface;\n}\n\n// Declares base tool capabilities, each bound to a sandbox target exported\n// from sandbox.ts or to `harnessHost`. Targets are\n// resolved by identity to their export name at compile time.\nexport const baseTools = (base: BaseToolsInputIface): BaseToolsValueIface =>\n  stamp({ base: { ...base } }, AuthoredKind.BaseTools);\n"],
+  "mappings": "AAMA,SAAS,cAAc,aAAa;AAIpC,SAAS,uBAAuB,mBAAmB;AA6B5C,MAAM,cAAgC,MAAM,EAAE,aAAa,KAAK,GAAG,aAAa,WAAW;AAW3F,MAAM,gBAAgB,CAG3B,UACO,iBAAiB,WAAW,MAAM,OAAO,aAAa,eAAe,IAAI;AAa3E,MAAM,YAAY,CAAC,SACxB,MAAM,EAAE,MAAM,EAAE,GAAG,KAAK,EAAE,GAAG,aAAa,SAAS;",
+  "names": []
+}

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

@@ -0,0 +1,8 @@
+import type { ScheduleTarget } from '@finalai/agent-provider';
+export interface ScheduleInputIface {
+    readonly cron: string;
+    readonly markdown?: string;
+    readonly timezone?: string;
+    readonly target?: ScheduleTarget | `${ScheduleTarget}`;
+}
+export declare const defineSchedule: <TSchedule extends ScheduleInputIface>(definition: TSchedule) => TSchedule;

package/dist/modules/authoring/schedules.mjs

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

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/authoring/schedules.ts"],
+  "sourcesContent": ["import type { ScheduleTarget } from '@finalai/agent-provider';\nimport { AuthoredKind, stamp } from \"./brand.mjs\";\n\n// A schedule authored in TypeScript (`schedules/<key>.ts`); the markdown form\n// (`schedules/<key>.md` with cron/timezone/target front matter) compiles the\n// same: a schedule is a prompt delivered to its target.\nexport interface ScheduleInputIface {\n  readonly cron: string;\n  readonly markdown?: string;\n  readonly timezone?: string;\n  readonly target?: ScheduleTarget | `${ScheduleTarget}`;\n}\n\nexport const defineSchedule = <TSchedule extends ScheduleInputIface>(\n  definition: TSchedule,\n): TSchedule => stamp({ ...definition }, AuthoredKind.Schedule);\n"],
+  "mappings": "AACA,SAAS,cAAc,aAAa;AAY7B,MAAM,iBAAiB,CAC5B,eACc,MAAM,EAAE,GAAG,WAAW,GAAG,aAAa,QAAQ;",
+  "names": []
+}

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

@@ -0,0 +1,8 @@
+export interface SkillDefinitionIface {
+    readonly description: string;
+    readonly markdown: string;
+    readonly license?: string;
+    readonly metadata?: Record<string, string>;
+    readonly files?: Readonly<Record<string, string | Uint8Array>>;
+}
+export declare const defineSkill: <TSkill extends SkillDefinitionIface>(definition: TSkill) => TSkill;

package/dist/modules/authoring/skills.mjs

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

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/authoring/skills.ts"],
+  "sourcesContent": ["import { AuthoredKind, stamp } from \"./brand.mjs\";\n\n// defineSkill: a skill package whose name comes from its path under\n// skills/ (or the dynamic resolver's slug). Compiles into one entry of\n// `harness.config.skills` with SKILL.md first.\nexport interface SkillDefinitionIface {\n  readonly description: string;\n  readonly markdown: string;\n  readonly license?: string;\n  readonly metadata?: Record<string, string>;\n  // Package-relative sibling files. Binary content is not supported.\n  readonly files?: Readonly<Record<string, string | Uint8Array>>;\n}\n\nexport const defineSkill = <TSkill extends SkillDefinitionIface>(definition: TSkill): TSkill =>\n  stamp({ ...definition }, AuthoredKind.Skill);\n"],
+  "mappings": "AAAA,SAAS,cAAc,aAAa;AAc7B,MAAM,cAAc,CAAsC,eAC/D,MAAM,EAAE,GAAG,WAAW,GAAG,aAAa,KAAK;",
+  "names": []
+}

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

@@ -0,0 +1,80 @@
+import type { JsonObject, JsonValue } from '@finalai/agent-provider';
+import * as z from 'zod';
+import { type AuthoredValue } from "../runtime/values.mjs";
+import type { ApprovalPolicyIface } from "./approval.mjs";
+import type { ToolContextIface } from "./context.mjs";
+export interface StandardSchemaLikeIface<Input = AuthoredValue, Output = Input> {
+    readonly '~standard': {
+        readonly version: 1;
+        readonly vendor: string;
+        readonly validate: (value: AuthoredValue) => AuthoredValue;
+        readonly types?: {
+            readonly input: Input;
+            readonly output: Output;
+        } | undefined;
+    };
+}
+export type ToolInputSchema = StandardSchemaLikeIface | JsonObject;
+export type InferSchemaOutput<TSchema> = TSchema extends {
+    readonly '~standard': {
+        readonly types?: infer TTypes;
+    };
+} ? NonNullable<TTypes> extends {
+    readonly output: infer TOutput;
+} ? TOutput : JsonObject : JsonObject;
+export type ToolOutputOf<TReturn> = TReturn extends Promise<infer TOutput> ? TOutput : TReturn extends AsyncIterable<infer TOutput> ? TOutput : TReturn;
+export interface ToolLabelIface<TInput, TOutput, TPartial = TOutput> {
+    start(input: Readonly<TInput>): string;
+    delta?(input: Readonly<TInput>, partial: Readonly<TPartial>): string;
+    complete?(input: Readonly<TInput>, output: Readonly<TOutput>): string;
+}
+export declare const toolLabelSchema: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    start: z.ZodCustom<import("../runtime/values.mjs").AuthoredCallable, import("../runtime/values.mjs").AuthoredCallable>;
+    delta: z.ZodOptional<z.ZodCustom<import("../runtime/values.mjs").AuthoredCallable, import("../runtime/values.mjs").AuthoredCallable>>;
+    complete: z.ZodOptional<z.ZodCustom<import("../runtime/values.mjs").AuthoredCallable, import("../runtime/values.mjs").AuthoredCallable>>;
+}, z.core.$strip>]>;
+export interface ToolAnnotationsIface {
+    title?: string;
+    readOnlyHint?: boolean;
+    destructiveHint?: boolean;
+    idempotentHint?: boolean;
+    openWorldHint?: boolean;
+}
+export interface ToolDefinitionIface<TInput, TOutput, TReturn = unknown> {
+    readonly description: string;
+    readonly inputSchema: ToolInputSchema;
+    readonly outputSchema?: ToolInputSchema;
+    execute(input: TInput, ctx: ToolContextIface): TReturn;
+    readonly approval?: ApprovalPolicyIface<TInput>;
+    readonly label?: string | ToolLabelIface<TInput, TOutput, ToolOutputOf<TReturn>>;
+    readonly toModelOutput?: (output: TOutput) => JsonValue | Promise<JsonValue>;
+    readonly annotations?: ToolAnnotationsIface;
+    readonly endsTurn?: boolean | ((output: TOutput) => boolean | Promise<boolean>);
+}
+export interface DefinedToolIface<TInput, TOutput, TReturn = unknown> extends ToolDefinitionIface<TInput, TOutput, TReturn> {
+    readonly __output?: TOutput;
+}
+type ValidatedToolOutput<TSchema, TReturn> = ToolInputSchema extends TSchema ? ToolOutputOf<TReturn> : TSchema extends {
+    readonly '~standard': object;
+} ? InferSchemaOutput<TSchema> : ToolOutputOf<TReturn>;
+export declare const defineTool: <TSchema extends ToolInputSchema, TReturn, TOutputSchema extends ToolInputSchema | undefined = ToolInputSchema | undefined>(definition: ToolDefinitionIface<InferSchemaOutput<TSchema>, ValidatedToolOutput<TOutputSchema, TReturn>, TReturn> & {
+    readonly inputSchema: TSchema;
+    readonly outputSchema?: TOutputSchema;
+}) => DefinedToolIface<InferSchemaOutput<TSchema>, ValidatedToolOutput<TOutputSchema, TReturn>, TReturn>;
+export declare const registerToolName: (tool: AuthoredValue, name: string) => void;
+export interface ToolCallEventDataIface {
+    toolCallId: string;
+    status: string | null;
+    toolName: string | null;
+    title: string | null;
+    rawInput: Record<string, JsonValue>;
+    rawOutput: JsonValue | null;
+}
+export declare const toolResultFrom: <TOutput>(event: {
+    readonly type: string;
+    readonly data: AuthoredValue;
+}, tool: {
+    readonly __output?: TOutput;
+    readonly outputSchema?: ToolInputSchema;
+}) => TOutput | undefined;
+export { defineDynamic } from "./dynamic.mjs";

package/dist/modules/authoring/tools.mjs

@@ -0,0 +1,70 @@
+import * as z from "zod";
+import { resultMatchesSchema } from "../runtime/schema-validation.mjs";
+import {
+  callableSchema,
+  isObjectLike,
+  optionalValueSchema
+} from "../runtime/values.mjs";
+import { AuthoredKind, stamp } from "./brand.mjs";
+const toolLabelSchema = z.union([
+  z.string(),
+  z.object({
+    start: callableSchema,
+    delta: callableSchema.optional(),
+    complete: callableSchema.optional()
+  })
+]);
+const defineTool = (definition) => stamp({ ...definition }, AuthoredKind.Tool);
+const toolNames = /* @__PURE__ */ new WeakMap();
+const registerToolName = (tool, name) => {
+  if (!isObjectLike(tool)) return;
+  toolNames.set(tool, [...toolNames.get(tool) ?? [], name]);
+};
+const nameMatches = (qualified, name) => qualified === name || qualified.endsWith(`/${name}`) || qualified.endsWith(`__${name}`);
+const toolCallUpdateSchema = z.looseObject({
+  status: z.string().nullish(),
+  toolName: z.string(),
+  rawOutput: optionalValueSchema
+});
+const mcpResultSchema = z.looseObject({
+  isError: z.boolean().optional(),
+  structuredContent: optionalValueSchema,
+  content: z.array(z.looseObject({ type: z.string(), text: z.string().optional() })).optional()
+});
+const toolOutputOf = (rawOutput) => {
+  const result = mcpResultSchema.safeParse(rawOutput);
+  if (!result.success) return { output: rawOutput, failed: false };
+  if (result.data.isError === true) return { output: null, failed: true };
+  if (result.data.structuredContent != null)
+    return { output: result.data.structuredContent, failed: false };
+  const text = result.data.content?.find((block) => block.type === "text")?.text;
+  if (text == null) return { output: rawOutput, failed: false };
+  try {
+    const parsed = JSON.parse(text);
+    return { output: parsed, failed: false };
+  } catch {
+    return { output: text, failed: false };
+  }
+};
+const isToolOutput = (tool, value) => resultMatchesSchema(tool.outputSchema, value);
+const toolResultFrom = (event, tool) => {
+  if (event.type !== "tool_call_update") return void 0;
+  const data = toolCallUpdateSchema.safeParse(event.data);
+  if (!data.success) return void 0;
+  if (data.data.status != null && data.data.status !== "completed") return void 0;
+  const qualified = data.data.toolName;
+  const names = isObjectLike(tool) ? toolNames.get(tool) ?? [] : [];
+  if (!names.some((name) => nameMatches(qualified, name))) return void 0;
+  const { output, failed } = toolOutputOf(data.data.rawOutput);
+  if (failed) return void 0;
+  return isToolOutput(tool, output) ? output : void 0;
+};
+import { defineDynamic } from "./dynamic.mjs";
+export {
+  defineDynamic,
+  defineTool,
+  registerToolName,
+  toolLabelSchema,
+  toolResultFrom
+};
+//# sourceMappingURL=tools.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/authoring/tools.ts"],
+  "sourcesContent": ["import type { JsonObject, JsonValue } from '@finalai/agent-provider';\nimport * as z from 'zod';\nimport { resultMatchesSchema } from \"../runtime/schema-validation.mjs\";\nimport {\n  callableSchema,\n  isObjectLike,\n  optionalValueSchema,\n  type AuthoredValue,\n} from \"../runtime/values.mjs\";\nimport type { ApprovalPolicyIface } from \"./approval.mjs\";\nimport { AuthoredKind, stamp } from \"./brand.mjs\";\nimport type { ToolContextIface } from \"./context.mjs\";\n\n// Authored tools are exposed through MCP. `endsTurn` is rejected at compile\n// time because the harness owns the loop.\n\n// The Standard Schema surface (zod 4, valibot, arktype) that tools accept.\nexport interface StandardSchemaLikeIface<Input = AuthoredValue, Output = Input> {\n  readonly '~standard': {\n    readonly version: 1;\n    readonly vendor: string;\n    readonly validate: (value: AuthoredValue) => AuthoredValue;\n    readonly types?: { readonly input: Input; readonly output: Output } | undefined;\n  };\n}\n\nexport type ToolInputSchema = StandardSchemaLikeIface | JsonObject;\n\nexport type InferSchemaOutput<TSchema> = TSchema extends {\n  readonly '~standard': { readonly types?: infer TTypes };\n}\n  ? NonNullable<TTypes> extends { readonly output: infer TOutput }\n    ? TOutput\n    : JsonObject\n  : JsonObject;\n\nexport type ToolOutputOf<TReturn> =\n  TReturn extends Promise<infer TOutput>\n    ? TOutput\n    : TReturn extends AsyncIterable<infer TOutput>\n      ? TOutput\n      : TReturn;\n\nexport interface ToolLabelIface<TInput, TOutput, TPartial = TOutput> {\n  start(input: Readonly<TInput>): string;\n  delta?(input: Readonly<TInput>, partial: Readonly<TPartial>): string;\n  complete?(input: Readonly<TInput>, output: Readonly<TOutput>): string;\n}\n\nexport const toolLabelSchema = z.union([\n  z.string(),\n  z.object({\n    start: callableSchema,\n    delta: callableSchema.optional(),\n    complete: callableSchema.optional(),\n  }),\n]);\n\nexport interface ToolAnnotationsIface {\n  title?: string;\n  readOnlyHint?: boolean;\n  destructiveHint?: boolean;\n  idempotentHint?: boolean;\n  openWorldHint?: boolean;\n}\n\nexport interface ToolDefinitionIface<TInput, TOutput, TReturn = unknown> {\n  readonly description: string;\n  readonly inputSchema: ToolInputSchema;\n  readonly outputSchema?: ToolInputSchema;\n  // Returns the output, a promise of it, or an async iterable whose yields are\n  // progress and whose last value is the output.\n  execute(input: TInput, ctx: ToolContextIface): TReturn;\n  readonly approval?: ApprovalPolicyIface<TInput>;\n  // A plain string becomes the MCP tool title.\n  readonly label?: string | ToolLabelIface<TInput, TOutput, ToolOutputOf<TReturn>>;\n  readonly toModelOutput?: (output: TOutput) => JsonValue | Promise<JsonValue>;\n  readonly annotations?: ToolAnnotationsIface;\n  // Rejected at compile time: the harness owns the loop.\n  readonly endsTurn?: boolean | ((output: TOutput) => boolean | Promise<boolean>);\n}\n\nexport interface DefinedToolIface<TInput, TOutput, TReturn = unknown> extends ToolDefinitionIface<\n  TInput,\n  TOutput,\n  TReturn\n> {\n  // Type-level only: lets toolResultFrom narrow to this tool's output.\n  readonly __output?: TOutput;\n}\n\ntype ValidatedToolOutput<TSchema, TReturn> = ToolInputSchema extends TSchema\n  ? ToolOutputOf<TReturn>\n  : TSchema extends { readonly '~standard': object }\n    ? InferSchemaOutput<TSchema>\n    : ToolOutputOf<TReturn>;\n\nexport const defineTool = <\n  TSchema extends ToolInputSchema,\n  TReturn,\n  TOutputSchema extends ToolInputSchema | undefined = ToolInputSchema | undefined,\n>(\n  definition: ToolDefinitionIface<\n    InferSchemaOutput<TSchema>,\n    ValidatedToolOutput<TOutputSchema, TReturn>,\n    TReturn\n  > & {\n    readonly inputSchema: TSchema;\n    readonly outputSchema?: TOutputSchema;\n  },\n): DefinedToolIface<\n  InferSchemaOutput<TSchema>,\n  ValidatedToolOutput<TOutputSchema, TReturn>,\n  TReturn\n> => stamp({ ...definition }, AuthoredKind.Tool);\n\nconst toolNames = new WeakMap<object, string[]>();\n\n// Called by the bundle for every authored tool, so hooks can match tool_call\n// updates to the tool definitions they import.\nexport const registerToolName = (tool: AuthoredValue, name: string): void => {\n  if (!isObjectLike(tool)) return;\n  toolNames.set(tool, [...(toolNames.get(tool) ?? []), name]);\n};\n\nexport interface ToolCallEventDataIface {\n  toolCallId: string;\n  status: string | null;\n  // Qualified name (`<serverKey>/<tool>`) the session service attaches from the\n  // MCP host's call record; null for harness-native tools.\n  toolName: string | null;\n  title: string | null;\n  rawInput: Record<string, JsonValue>;\n  rawOutput: JsonValue | null;\n}\n\nconst nameMatches = (qualified: string, name: string): boolean =>\n  qualified === name || qualified.endsWith(`/${name}`) || qualified.endsWith(`__${name}`);\n\nconst toolCallUpdateSchema = z.looseObject({\n  status: z.string().nullish(),\n  toolName: z.string(),\n  rawOutput: optionalValueSchema,\n});\n\nconst mcpResultSchema = z.looseObject({\n  isError: z.boolean().optional(),\n  structuredContent: optionalValueSchema,\n  content: z.array(z.looseObject({ type: z.string(), text: z.string().optional() })).optional(),\n});\n\n// An MCP call result's structured content, or its first text block parsed as JSON.\ninterface ParsedToolOutputIface {\n  output: AuthoredValue;\n  failed: boolean;\n}\n\nconst toolOutputOf = (rawOutput: AuthoredValue): ParsedToolOutputIface => {\n  const result = mcpResultSchema.safeParse(rawOutput);\n  if (!result.success) return { output: rawOutput, failed: false };\n  if (result.data.isError === true) return { output: null, failed: true };\n  if (result.data.structuredContent != null)\n    return { output: result.data.structuredContent, failed: false };\n  const text = result.data.content?.find((block) => block.type === 'text')?.text;\n  if (text == null) return { output: rawOutput, failed: false };\n  try {\n    const parsed: AuthoredValue = JSON.parse(text);\n    return { output: parsed, failed: false };\n  } catch {\n    return { output: text, failed: false };\n  }\n};\n\n// A tool without an output schema is trusted, as first-party tRPC responses are.\nconst isToolOutput = <TOutput>(\n  tool: { readonly __output?: TOutput; readonly outputSchema?: ToolInputSchema },\n  value: AuthoredValue,\n): value is TOutput => resultMatchesSchema(tool.outputSchema, value);\n\n// Narrows a completed tool_call update to one authored tool's output.\n// Returns undefined for other tools, unfinished calls and errors.\nexport const toolResultFrom = <TOutput>(\n  event: { readonly type: string; readonly data: AuthoredValue },\n  tool: { readonly __output?: TOutput; readonly outputSchema?: ToolInputSchema },\n): TOutput | undefined => {\n  if (event.type !== 'tool_call_update') return undefined;\n  const data = toolCallUpdateSchema.safeParse(event.data);\n  if (!data.success) return undefined;\n  if (data.data.status != null && data.data.status !== 'completed') return undefined;\n  const qualified = data.data.toolName;\n  const names = isObjectLike(tool) ? (toolNames.get(tool) ?? []) : [];\n  if (!names.some((name) => nameMatches(qualified, name))) return undefined;\n  const { output, failed } = toolOutputOf(data.data.rawOutput);\n  if (failed) return undefined;\n  return isToolOutput(tool, output) ? output : undefined;\n};\n\nexport { defineDynamic } from \"./dynamic.mjs\";\n"],
+  "mappings": "AACA,YAAY,OAAO;AACnB,SAAS,2BAA2B;AACpC;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OAEK;AAEP,SAAS,cAAc,aAAa;AAuC7B,MAAM,kBAAkB,EAAE,MAAM;AAAA,EACrC,EAAE,OAAO;AAAA,EACT,EAAE,OAAO;AAAA,IACP,OAAO;AAAA,IACP,OAAO,eAAe,SAAS;AAAA,IAC/B,UAAU,eAAe,SAAS;AAAA,EACpC,CAAC;AACH,CAAC;AAyCM,MAAM,aAAa,CAKxB,eAYG,MAAM,EAAE,GAAG,WAAW,GAAG,aAAa,IAAI;AAE/C,MAAM,YAAY,oBAAI,QAA0B;AAIzC,MAAM,mBAAmB,CAAC,MAAqB,SAAuB;AAC3E,MAAI,CAAC,aAAa,IAAI,EAAG;AACzB,YAAU,IAAI,MAAM,CAAC,GAAI,UAAU,IAAI,IAAI,KAAK,CAAC,GAAI,IAAI,CAAC;AAC5D;AAaA,MAAM,cAAc,CAAC,WAAmB,SACtC,cAAc,QAAQ,UAAU,SAAS,IAAI,IAAI,EAAE,KAAK,UAAU,SAAS,KAAK,IAAI,EAAE;AAExF,MAAM,uBAAuB,EAAE,YAAY;AAAA,EACzC,QAAQ,EAAE,OAAO,EAAE,QAAQ;AAAA,EAC3B,UAAU,EAAE,OAAO;AAAA,EACnB,WAAW;AACb,CAAC;AAED,MAAM,kBAAkB,EAAE,YAAY;AAAA,EACpC,SAAS,EAAE,QAAQ,EAAE,SAAS;AAAA,EAC9B,mBAAmB;AAAA,EACnB,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,OAAO,GAAG,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC,CAAC,EAAE,SAAS;AAC9F,CAAC;AAQD,MAAM,eAAe,CAAC,cAAoD;AACxE,QAAM,SAAS,gBAAgB,UAAU,SAAS;AAClD,MAAI,CAAC,OAAO,QAAS,QAAO,EAAE,QAAQ,WAAW,QAAQ,MAAM;AAC/D,MAAI,OAAO,KAAK,YAAY,KAAM,QAAO,EAAE,QAAQ,MAAM,QAAQ,KAAK;AACtE,MAAI,OAAO,KAAK,qBAAqB;AACnC,WAAO,EAAE,QAAQ,OAAO,KAAK,mBAAmB,QAAQ,MAAM;AAChE,QAAM,OAAO,OAAO,KAAK,SAAS,KAAK,CAAC,UAAU,MAAM,SAAS,MAAM,GAAG;AAC1E,MAAI,QAAQ,KAAM,QAAO,EAAE,QAAQ,WAAW,QAAQ,MAAM;AAC5D,MAAI;AACF,UAAM,SAAwB,KAAK,MAAM,IAAI;AAC7C,WAAO,EAAE,QAAQ,QAAQ,QAAQ,MAAM;AAAA,EACzC,QAAQ;AACN,WAAO,EAAE,QAAQ,MAAM,QAAQ,MAAM;AAAA,EACvC;AACF;AAGA,MAAM,eAAe,CACnB,MACA,UACqB,oBAAoB,KAAK,cAAc,KAAK;AAI5D,MAAM,iBAAiB,CAC5B,OACA,SACwB;AACxB,MAAI,MAAM,SAAS,mBAAoB,QAAO;AAC9C,QAAM,OAAO,qBAAqB,UAAU,MAAM,IAAI;AACtD,MAAI,CAAC,KAAK,QAAS,QAAO;AAC1B,MAAI,KAAK,KAAK,UAAU,QAAQ,KAAK,KAAK,WAAW,YAAa,QAAO;AACzE,QAAM,YAAY,KAAK,KAAK;AAC5B,QAAM,QAAQ,aAAa,IAAI,IAAK,UAAU,IAAI,IAAI,KAAK,CAAC,IAAK,CAAC;AAClE,MAAI,CAAC,MAAM,KAAK,CAAC,SAAS,YAAY,WAAW,IAAI,CAAC,EAAG,QAAO;AAChE,QAAM,EAAE,QAAQ,OAAO,IAAI,aAAa,KAAK,KAAK,SAAS;AAC3D,MAAI,OAAQ,QAAO;AACnB,SAAO,aAAa,MAAM,MAAM,IAAI,SAAS;AAC/C;AAEA,SAAS,qBAAqB;",
+  "names": []
+}

package/dist/modules/compatibility.d.mts

@@ -0,0 +1,36 @@
+import { type AgentManifestIface, type HarnessDescriptionIface, type JsonValue, type ProviderRef } from '@finalai/agent-provider';
+export declare enum CompatibilityResult {
+    Valid = "valid",
+    Invalid = "invalid",
+    Applies = "applies",
+    Unused = "unused",
+    Transformed = "transformed",
+    Unavailable = "unavailable",
+    Host = "host",
+    Absent = "absent",
+    Dynamic = "dynamic"
+}
+export interface CompatibilityRowIface {
+    item: string;
+    result: CompatibilityResult;
+    why: string;
+}
+export interface CompatibilityReportIface {
+    harness: ProviderRef;
+    ok: boolean;
+    rows: CompatibilityRowIface[];
+}
+export interface DirectoryFieldFilesIface {
+    instructions: string[];
+    skills: string[];
+}
+export interface CompatibilityReportArgsIface {
+    manifest: AgentManifestIface;
+    description: HarnessDescriptionIface;
+    directoryFiles?: DirectoryFieldFilesIface;
+}
+export declare const harnessConfigError: (args: {
+    config: JsonValue;
+    description: HarnessDescriptionIface;
+}) => string | null;
+export declare const compatibilityReport: (args: CompatibilityReportArgsIface) => CompatibilityReportIface;