@telnyx/agent-harness 0.1.0-beta.0

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+/** Private Agent harness foundation and turn engine. Never publish this working package. */
+export * from "./ports.js";
+export * from "./runtime-adapter.js";
+export * from "./harness.js";
+export { HARNESS_RUN_STATUSES, HarnessApprovalPause, HarnessInjectedCrash, createHarnessRunLedger, ensureHarnessDurabilitySchema, type HarnessCheckpoint, type HarnessRun, type HarnessRunAcceptance, type HarnessRunLedger, type HarnessRunLedgerOptions, type HarnessRunListOptions, type HarnessRunStatus, } from "./durable.js";
+export { HARNESS_APPROVAL_STATUSES, HarnessApprovalError, HarnessAuthorizationError, type HarnessApproval, type HarnessApprovalLedger, type HarnessApprovalStatus, } from "./approvals.js";
+export * from "./steps.js";
+export * from "./lifecycle.js";
+export * from "./channel.js";
+export * from "./scheduling.js";
+export * from "./workspace.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,19 @@
+/** Private Agent harness foundation and turn engine. Never publish this working package. */
+export * from "./ports.js";
+export * from "./runtime-adapter.js";
+// node-adapter is deliberately NOT re-exported: it pulls in the Node-only
+// SQLite storage, whose module-level createRequire(import.meta.url) throws
+// when the deploy pipeline stages a customer bundle as CommonJS (import.meta
+// is empty there). Deployed actors get their storage from the runtime; the
+// Node adapter is a local/test concern — consumers import it from the
+// "@telnyx/agent-harness/node" subpath (internal code from
+// "./node-adapter.js"). The clean-consumer CI check enforces both directions.
+export * from "./harness.js";
+export { HARNESS_RUN_STATUSES, HarnessApprovalPause, HarnessInjectedCrash, createHarnessRunLedger, ensureHarnessDurabilitySchema, } from "./durable.js";
+export { HARNESS_APPROVAL_STATUSES, HarnessApprovalError, HarnessAuthorizationError, } from "./approvals.js";
+export * from "./steps.js";
+export * from "./lifecycle.js";
+export * from "./channel.js";
+export * from "./scheduling.js";
+export * from "./workspace.js";
+//# sourceMappingURL=index.js.map

package/dist/lifecycle.d.ts

@@ -0,0 +1,9 @@
+/** Stable error raised when a lifecycle middleware attempts to advance twice. */
+export declare class HarnessMiddlewareError extends Error {
+    readonly code: "HARNESS_MIDDLEWARE_NEXT";
+    constructor();
+}
+export type HarnessMiddleware<Context, Result> = (context: Readonly<Context>, next: () => Promise<Result>) => Promise<Result> | Result;
+/** Executes one immutable lifecycle snapshot in registered onion order. */
+export declare function runMiddleware<Context, Result>(context: Readonly<Context>, middleware: readonly HarnessMiddleware<Context, Result>[], core: () => Promise<Result>): Promise<Result>;
+//# sourceMappingURL=lifecycle.d.ts.map

package/dist/lifecycle.js

@@ -0,0 +1,25 @@
+/** Stable error raised when a lifecycle middleware attempts to advance twice. */
+export class HarnessMiddlewareError extends Error {
+    code = "HARNESS_MIDDLEWARE_NEXT";
+    constructor() {
+        super("Harness middleware may call next() at most once");
+        this.name = "HarnessMiddlewareError";
+    }
+}
+/** Executes one immutable lifecycle snapshot in registered onion order. */
+export async function runMiddleware(context, middleware, core) {
+    const dispatch = async (index) => {
+        const current = middleware[index];
+        if (current === undefined)
+            return core();
+        let advanced = false;
+        return current(context, async () => {
+            if (advanced)
+                throw new HarnessMiddlewareError();
+            advanced = true;
+            return dispatch(index + 1);
+        });
+    };
+    return dispatch(0);
+}
+//# sourceMappingURL=lifecycle.js.map

package/dist/node-adapter.d.ts

@@ -0,0 +1,71 @@
+import { type StoredEvent, type StoredMessage, type TaskDispatch, type TaskRecord } from "@telnyx/edge-runtime/internal";
+import { type AgentHarnessEventPort, type HarnessAuthorizationPort, type AgentHarnessMessagePort, type AgentHarnessPorts, type AgentHarnessSqlPort, type AgentHarnessStatePort, type AgentHarnessTaskPort } from "./ports.js";
+interface NodeBacking<State extends Record<string, unknown>> {
+    messageSeq: number;
+    messages: StoredMessage[];
+    eventSeq: number;
+    events: StoredEvent[];
+    state: State | undefined;
+    tasks: Map<string, TaskRecord>;
+    nextTaskId: number;
+    sql: AgentHarnessSqlPort & {
+        close(): void;
+    };
+    closed: boolean;
+}
+/** Options for the deterministic plain-Node adapter. */
+export interface NodeAgentHarnessPortsOptions<State extends Record<string, unknown>> {
+    id: string;
+    now: () => number;
+    initialState: () => State;
+    databasePath: string;
+    environment?: Readonly<Record<string, unknown>>;
+    /** Deterministic authorization adapter for tests; production hosts provide an attested gateway provider. */
+    authorization?: HarnessAuthorizationPort;
+    /**
+     * Optional Agent-compatible hook fired after a state merge or replacement is
+     * committed. A rejection propagates without rolling the committed state back.
+     */
+    onStateChanged?: (next: State, prev: State) => void | Promise<void>;
+}
+/**
+ * Deterministic plain-Node implementation of AgentHarnessPorts v2.
+ *
+ * KV-like data is in memory and survives `reopen()` only; SQL is file-backed
+ * through Node's experimental `node:sqlite` API and requires Node 22.13 or
+ * newer without runtime flags. This is a contract-test host, not a production
+ * durability claim.
+ */
+export declare class NodeAgentHarnessPorts<State extends Record<string, unknown> = Record<string, unknown>> implements AgentHarnessPorts<State> {
+    private readonly options;
+    private readonly backing;
+    readonly version: 2;
+    readonly identity: Readonly<{
+        id: string;
+    }>;
+    readonly activation: Readonly<{}>;
+    readonly clock: Readonly<{
+        now(): number;
+    }>;
+    readonly authorization: HarnessAuthorizationPort | undefined;
+    readonly environment: Readonly<Record<string, unknown>>;
+    readonly messages: AgentHarnessMessagePort;
+    readonly state: AgentHarnessStatePort<State>;
+    readonly events: AgentHarnessEventPort;
+    readonly tasks: AgentHarnessTaskPort;
+    readonly sql: AgentHarnessSqlPort;
+    constructor(options: NodeAgentHarnessPortsOptions<State>, backing?: NodeBacking<State>);
+    /** Reconstruct the adapter while retaining its in-process durable backing. */
+    reopen(): NodeAgentHarnessPorts<State>;
+    /**
+     * Pump due tasks for deterministic Node tests. This is a host control, not an
+     * AgentHarnessPorts method or a durable run-status API.
+     */
+    runDue(dispatch: TaskDispatch): Promise<number>;
+    /** Close the fixture-owned SQLite database. Idempotent. */
+    close(): void;
+}
+/** Construct a deterministic plain-Node ports adapter. */
+export declare function createNodeAgentHarnessPorts<State extends Record<string, unknown>>(options: NodeAgentHarnessPortsOptions<State>): NodeAgentHarnessPorts<State>;
+export {};
+//# sourceMappingURL=node-adapter.d.ts.map