@infinityi/engine-lib 1.0.0 → 1.4.0

package/dist/context/providers.d.ts

@@ -8,18 +8,18 @@
  */
 import type { Message } from "../messages/types";
 import type { EngineContext } from "../runtime/types";
-import type { ContextProvider } from "./types";
+import type { ContextProvider, ContextResolveContext } from "./types";
 /**
  * Inject static facts verbatim. `content` is rendered as-is (strings) or
  * JSON-encoded; an optional `title` becomes a markdown heading.
  */
 export declare function staticContext(content: unknown, title?: string): ContextProvider;
 /** Inject context computed lazily at run time from the {@link EngineContext}. */
-export declare function dynamicContext(name: string, fn: (ctx: EngineContext) => unknown | Promise<unknown>, title?: string): ContextProvider;
+export declare function dynamicContext(name: string, fn: (ctx: EngineContext, run?: ContextResolveContext) => unknown | Promise<unknown>, title?: string): ContextProvider;
 /**
  * Resolve all providers and fold their items into a single `system` message
  * (the injected-context block), or `[]` when there is nothing to inject.
  * Providers resolve concurrently; their declaration order is preserved in the
  * output.
  */
-export declare function resolveContext(providers: readonly ContextProvider[] | undefined, ctx: EngineContext): Promise<Message[]>;
+export declare function resolveContext(providers: readonly ContextProvider[] | undefined, ctx: EngineContext, run?: ContextResolveContext): Promise<Message[]>;

package/dist/context/types.d.ts

@@ -22,13 +22,28 @@ export interface ContextItem {
     /** Strings pass through; anything else is JSON-encoded when rendered. */
     readonly content: unknown;
 }
+/** Run-specific facts made available while resolving context providers. */
+export interface ContextResolveContext {
+    /** Active agent name for this run. */
+    readonly agentName: string;
+    /** Resolved agent instructions, when any. */
+    readonly instructions?: string;
+    /** New input messages for this run. */
+    readonly input: readonly Message[];
+    /** Prior conversation history loaded before this run's input. */
+    readonly prior: readonly Message[];
+    /** Prior history followed by this run's input, excluding instructions/context. */
+    readonly messages: readonly Message[];
+    /** Per-run context-window configuration, when supplied. */
+    readonly contextWindow?: ContextWindowOptions;
+}
 /**
  * A host-supplied context source, resolved once per run before the first
  * provider call. Results are injected as system context and are not persisted.
  */
 export interface ContextProvider {
     readonly name: string;
-    resolve(ctx: EngineContext): ContextItem[] | Promise<ContextItem[]>;
+    resolve(ctx: EngineContext, run?: ContextResolveContext): ContextItem[] | Promise<ContextItem[]>;
 }
 /** Counts tokens for a message list (pluggable; a char-based heuristic ships built-in). */
 export type TokenCounter = (messages: readonly Message[]) => number;

package/dist/errors.d.ts

@@ -91,3 +91,21 @@ export declare class ContextWindowError extends AgentError {
         limit?: number;
     });
 }
+/**
+ * The optional `tools-shell` module was misconfigured (e.g. an `allowedCwds`
+ * entry that is not an absolute path). Thrown for host-side configuration
+ * faults at factory-build time — policy *denials* of a model's command are not
+ * errors; those return `{ ok: false, error }` from the tool so the model can
+ * recover.
+ */
+export declare class ShellPolicyError extends AgentError {
+    constructor(message: string, options?: ErrorOptions);
+}
+/**
+ * The optional `tools-fs` module was misconfigured (for example, missing
+ * absolute `allowedRoots`). Per-call filesystem denials are returned as tool
+ * failures so the model can recover.
+ */
+export declare class FilesystemPolicyError extends AgentError {
+    constructor(message: string, options?: ErrorOptions);
+}

package/dist/errors.js

@@ -3,20 +3,25 @@ import {
   CancelledError,
   ContextWindowError,
   ExecutionError,
+  FilesystemPolicyError,
   MaxHandoffsExceededError,
   MaxStepsExceededError,
   ProviderError,
   SchemaValidationError,
+  ShellPolicyError,
   ToolError,
   ToolValidationError
-} from "./index-7690reng.js";
+} from "./index-ajr3nk10.js";
+import"./index-37x76zdn.js";
 export {
   ToolValidationError,
   ToolError,
+  ShellPolicyError,
   SchemaValidationError,
   ProviderError,
   MaxStepsExceededError,
   MaxHandoffsExceededError,
+  FilesystemPolicyError,
   ExecutionError,
   ContextWindowError,
   CancelledError,

package/dist/events/index.js

@@ -3,7 +3,7 @@ import {
   eventPayload,
   loggingSubscriber,
   messageBusSubscriber
-} from "../index-jxgj4z08.js";
+} from "../index-9egrqxkf.js";
 import {
   SPAN_PROVIDER,
   SPAN_RUN,
@@ -11,6 +11,7 @@ import {
   createEventHub,
   createRunTelemetry
 } from "../index-fkr3rcq9.js";
+import"../index-37x76zdn.js";
 export {
   messageBusSubscriber,
   loggingSubscriber,

package/dist/execution/index.js

@@ -5,14 +5,19 @@ import {
   addUsage,
   emptyUsage,
   runAgent
-} from "../index-pwr8179t.js";
-import"../index-yrqrxwjt.js";
+} from "../index-7nb9qwa1.js";
 import"../index-fkr3rcq9.js";
-import"../index-02s1fjxr.js";
+import"../index-ycjsqfpq.js";
+import"../index-nvdsr51v.js";
+import"../index-c6kgts41.js";
+import"../index-k0q7x4mz.js";
 import"../index-zfgr4xx3.js";
-import"../index-7690reng.js";
 import"../index-rentvdpp.js";
 import"../index-1p6mb2vz.js";
+import"../index-mnx5mqbs.js";
+import"../index-4c15ysa8.js";
+import"../index-ajr3nk10.js";
+import"../index-37x76zdn.js";
 export {
   runAgent,
   emptyUsage,

package/dist/execution/types.d.ts

@@ -89,6 +89,20 @@ export type RunEvent = {
     readonly type: "agent.handoff";
     readonly from: string;
     readonly to: string;
+}
+/**
+ * An extension event emitted by an optional module or a custom tool through
+ * {@link RunBridge.emit}. `name` namespaces the event (e.g. `"shell.exec.start"`)
+ * and `data` is a JSON-serializable payload. The core loop never produces this
+ * variant; it is the stable seam for surfacing module-specific metadata (policy
+ * decisions, approvals, streamed output) onto the same subscriber/auditing
+ * stream as built-in events. Subscribers that don't recognize a `name` should
+ * ignore it.
+ */
+ | {
+    readonly type: "custom";
+    readonly name: string;
+    readonly data: Record<string, unknown>;
 };
 /**
  * A handle the run loop hands to a tool so it can participate in its parent run:

package/dist/index-37x76zdn.js

@@ -0,0 +1,4 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+export { __require };

package/dist/index-4c15ysa8.js

@@ -0,0 +1,84 @@
+// src/schema/validate.ts
+function issue(path, message) {
+  return { path: [...path], message };
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validateJsonSchema(node, input, path = []) {
+  const issues = [];
+  if (node.enum !== undefined) {
+    if (!node.enum.includes(input)) {
+      issues.push(issue(path, `expected one of ${JSON.stringify(node.enum)}`));
+    }
+    return issues;
+  }
+  switch (node.type) {
+    case "string":
+      if (typeof input !== "string")
+        issues.push(issue(path, "expected string"));
+      break;
+    case "boolean":
+      if (typeof input !== "boolean")
+        issues.push(issue(path, "expected boolean"));
+      break;
+    case "null":
+      if (input !== null)
+        issues.push(issue(path, "expected null"));
+      break;
+    case "number":
+      if (typeof input !== "number" || Number.isNaN(input)) {
+        issues.push(issue(path, "expected number"));
+      }
+      break;
+    case "integer":
+      if (typeof input !== "number" || !Number.isInteger(input)) {
+        issues.push(issue(path, "expected integer"));
+      }
+      break;
+    case "array": {
+      if (!Array.isArray(input)) {
+        issues.push(issue(path, "expected array"));
+        break;
+      }
+      if (node.items !== undefined) {
+        input.forEach((element, index) => {
+          issues.push(...validateJsonSchema(node.items, element, [...path, index]));
+        });
+      }
+      break;
+    }
+    case "object": {
+      if (!isPlainObject(input)) {
+        issues.push(issue(path, "expected object"));
+        break;
+      }
+      const properties = node.properties ?? {};
+      const required = node.required ?? [];
+      for (const key of required) {
+        if (input[key] === undefined) {
+          issues.push(issue([...path, key], "required"));
+        }
+      }
+      for (const [key, propSchema] of Object.entries(properties)) {
+        const value = input[key];
+        if (value === undefined)
+          continue;
+        issues.push(...validateJsonSchema(propSchema, value, [...path, key]));
+      }
+      if (node.additionalProperties === false) {
+        for (const key of Object.keys(input)) {
+          if (!(key in properties)) {
+            issues.push(issue([...path, key], "unexpected property"));
+          }
+        }
+      }
+      break;
+    }
+    default:
+      break;
+  }
+  return issues;
+}
+
+export { validateJsonSchema };

package/dist/{index-pwr8179t.js → index-7nb9qwa1.js}

@@ -1,7 +1,3 @@
-import {
-  applyContextWindow,
-  resolveContext
-} from "./index-yrqrxwjt.js";
 import {
   SPAN_PROVIDER,
   SPAN_RUN,
@@ -10,18 +6,14 @@ import {
   createRunTelemetry
 } from "./index-fkr3rcq9.js";
 import {
-  s
-} from "./index-02s1fjxr.js";
+  resolveContext
+} from "./index-ycjsqfpq.js";
+import {
+  applyContextWindow
+} from "./index-nvdsr51v.js";
 import {
   StreamAccumulator
 } from "./index-zfgr4xx3.js";
-import {
-  AgentError,
-  CancelledError,
-  ExecutionError,
-  MaxHandoffsExceededError,
-  MaxStepsExceededError
-} from "./index-7690reng.js";
 import {
   toProviderTool,
   toToolResultMessage
@@ -30,6 +22,16 @@ import {
   system,
   user
 } from "./index-1p6mb2vz.js";
+import {
+  s
+} from "./index-mnx5mqbs.js";
+import {
+  AgentError,
+  CancelledError,
+  ExecutionError,
+  MaxHandoffsExceededError,
+  MaxStepsExceededError
+} from "./index-ajr3nk10.js";
 
 // src/agent/registry.ts
 function createToolRegistry(tools) {
@@ -236,9 +238,16 @@ async function* executeAgent(agent, opts, tel) {
     throwIfAborted(opts.signal);
     yield { type: "run.start", agent: agent.name };
     const instructions = await resolveInstructions(agent, engineCtx);
-    const contextMessages = await resolveContext(opts.context, engineCtx);
     const prior = opts.session !== undefined ? await opts.session.messages() : opts.messages ?? [];
     const inputMessages = normalizeInput(opts.input);
+    const contextMessages = await resolveContext(opts.context, engineCtx, {
+      agentName: agent.name,
+      ...instructions !== undefined ? { instructions } : {},
+      input: inputMessages,
+      prior,
+      messages: [...prior, ...inputMessages],
+      ...opts.contextWindow !== undefined ? { contextWindow: opts.contextWindow } : {}
+    });
     const messages = [];
     if (instructions !== undefined && instructions !== "")
       messages.push(system(instructions));

package/dist/{index-jxgj4z08.js → index-9egrqxkf.js}

@@ -35,6 +35,8 @@ function eventFields(event) {
       return { agent: event.agent, depth: event.depth, child: event.event.type };
     case "agent.handoff":
       return { from: event.from, to: event.to };
+    case "custom":
+      return { name: event.name };
   }
 }
 function eventPayload(event) {
@@ -63,6 +65,8 @@ function eventPayload(event) {
       return { agent: event.agent, depth: event.depth, event: eventPayload(event.event) };
     case "agent.handoff":
       return { from: event.from, to: event.to };
+    case "custom":
+      return { name: event.name, data: event.data };
   }
 }
 export { loggingSubscriber, messageBusSubscriber, eventFields, eventPayload };

package/dist/{index-w34cbktd.js → index-a67ej96j.js}

@@ -11,4 +11,5 @@ function defineTool(spec) {
   };
   return Object.freeze(tool);
 }
+
 export { defineTool };

package/dist/{index-64tt9696.js → index-aed6fe4z.js}

@@ -4,13 +4,13 @@ import {
   exponentialBackoff,
   retry,
   timeout
-} from "./index-bqg01r42.js";
+} from "./index-zdggff0y.js";
 import {
   resolveSecret
-} from "./index-xsv43c5j.js";
+} from "./index-e14g2e48.js";
 import {
   ProviderError
-} from "./index-7690reng.js";
+} from "./index-ajr3nk10.js";
 // node_modules/@infinityi/forge/dist/index-r6ez01fw.js
 var PROBLEM_CONTENT_TYPE = "application/problem+json";
 var DEFAULT_PROBLEM_TYPE = "about:blank";

package/dist/{index-7690reng.js → index-ajr3nk10.js}

@@ -93,4 +93,18 @@ class ContextWindowError extends AgentError {
   }
 }
 
-export { AgentError, ProviderError, ToolError, SchemaValidationError, ToolValidationError, ExecutionError, MaxStepsExceededError, MaxHandoffsExceededError, CancelledError, ContextWindowError };
+class ShellPolicyError extends AgentError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ShellPolicyError";
+  }
+}
+
+class FilesystemPolicyError extends AgentError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "FilesystemPolicyError";
+  }
+}
+
+export { AgentError, ProviderError, ToolError, SchemaValidationError, ToolValidationError, ExecutionError, MaxStepsExceededError, MaxHandoffsExceededError, CancelledError, ContextWindowError, ShellPolicyError, FilesystemPolicyError };

package/dist/{index-xsv43c5j.js → index-e14g2e48.js}

@@ -24,10 +24,10 @@ function isSecret(value) {
   return value instanceof Secret;
 }
 
-// node_modules/@infinityi/forge/dist/index-y8kftjjy.js
+// node_modules/@infinityi/forge/dist/index-2dnw7sq9.js
 var LEAF_BRAND = Symbol.for("forge/config/leaf");
 
-// node_modules/@infinityi/forge/dist/index-yxhr4ame.js
+// node_modules/@infinityi/forge/dist/index-zhbta8s6.js
 var TRUE_TOKENS = new Set(["true", "1", "yes"]);
 var FALSE_TOKENS = new Set(["false", "0", "no"]);
 

package/dist/index-k0q7x4mz.js

@@ -0,0 +1,54 @@
+import {
+  validateJsonSchema
+} from "./index-4c15ysa8.js";
+import {
+  SchemaValidationError
+} from "./index-ajr3nk10.js";
+
+// src/schema/json-schema.ts
+function toJsonSchema(schema) {
+  return schema.jsonSchema;
+}
+function asSchema(impl) {
+  return {
+    jsonSchema: impl.jsonSchema,
+    parse: impl.parse.bind(impl),
+    safeParse: impl.safeParse?.bind(impl) ?? ((input) => {
+      try {
+        return { success: true, data: impl.parse(input) };
+      } catch (error) {
+        if (error instanceof SchemaValidationError)
+          return { success: false, error };
+        return {
+          success: false,
+          error: new SchemaValidationError("schema validation failed", {
+            cause: error,
+            issues: [{ path: [], message: String(error) }]
+          })
+        };
+      }
+    })
+  };
+}
+function fromJsonSchema(jsonSchema) {
+  return {
+    jsonSchema,
+    safeParse(input) {
+      const issues = validateJsonSchema(jsonSchema, input);
+      if (issues.length === 0)
+        return { success: true, data: input };
+      return {
+        success: false,
+        error: new SchemaValidationError("schema validation failed", { issues })
+      };
+    },
+    parse(input) {
+      const result = this.safeParse(input);
+      if (!result.success)
+        throw result.error;
+      return result.data;
+    }
+  };
+}
+
+export { toJsonSchema, asSchema, fromJsonSchema };

package/dist/index-mnx5mqbs.js

@@ -0,0 +1,102 @@
+import {
+  validateJsonSchema
+} from "./index-4c15ysa8.js";
+import {
+  SchemaValidationError
+} from "./index-ajr3nk10.js";
+
+// src/schema/builder.ts
+var optionalSchemas = new WeakSet;
+function makeSchema(jsonSchema) {
+  return {
+    jsonSchema,
+    safeParse(input) {
+      const issues = validateJsonSchema(jsonSchema, input);
+      if (issues.length === 0)
+        return { success: true, data: input };
+      return {
+        success: false,
+        error: new SchemaValidationError("schema validation failed", { issues })
+      };
+    },
+    parse(input) {
+      const result = this.safeParse(input);
+      if (!result.success)
+        throw result.error;
+      return result.data;
+    }
+  };
+}
+var s = {
+  string(opts) {
+    const node = { type: "string" };
+    if (opts?.description !== undefined)
+      node.description = opts.description;
+    if (opts?.enum !== undefined)
+      node.enum = opts.enum;
+    return makeSchema(node);
+  },
+  number(opts) {
+    const node = { type: opts?.int ? "integer" : "number" };
+    if (opts?.description !== undefined)
+      node.description = opts.description;
+    return makeSchema(node);
+  },
+  boolean(opts) {
+    const node = { type: "boolean" };
+    if (opts?.description !== undefined)
+      node.description = opts.description;
+    return makeSchema(node);
+  },
+  enum(values, opts) {
+    const node = { type: "string", enum: values };
+    if (opts?.description !== undefined)
+      node.description = opts.description;
+    return makeSchema(node);
+  },
+  array(item, opts) {
+    const node = { type: "array", items: item.jsonSchema };
+    if (opts?.description !== undefined)
+      node.description = opts.description;
+    return makeSchema(node);
+  },
+  object(props, opts) {
+    const properties = {};
+    const required = [];
+    for (const [key, prop] of Object.entries(props)) {
+      properties[key] = prop.jsonSchema;
+      if (!optionalSchemas.has(prop))
+        required.push(key);
+    }
+    const node = {
+      type: "object",
+      properties,
+      additionalProperties: false
+    };
+    if (required.length > 0)
+      node.required = required;
+    if (opts?.description !== undefined)
+      node.description = opts.description;
+    return makeSchema(node);
+  },
+  optional(inner) {
+    const schema = {
+      jsonSchema: inner.jsonSchema,
+      safeParse(input) {
+        if (input === undefined)
+          return { success: true, data: undefined };
+        return inner.safeParse(input);
+      },
+      parse(input) {
+        const result = this.safeParse(input);
+        if (!result.success)
+          throw result.error;
+        return result.data;
+      }
+    };
+    optionalSchemas.add(schema);
+    return schema;
+  }
+};
+
+export { s };