@memberjunction/ai-agent-harness 0.0.0 → 6.1.0-edge.2

package/dist/sandbox/ISandboxProvider.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ISandboxProvider.js.map

package/dist/sandbox/ISandboxProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ISandboxProvider.js","sourceRoot":"","sources":["../../src/sandbox/ISandboxProvider.ts"],"names":[],"mappings":""}

package/dist/sandbox/LocalDirectorySandboxProvider.d.ts

@@ -0,0 +1,37 @@
+import { ISandboxProvider, SandboxConfig, SandboxHandle, WorkspaceKey } from './ISandboxProvider.js';
+/**
+ * Phase-1 sandbox: a scoped directory on the MJ server's own filesystem.
+ *
+ * ## What this does and does not protect against
+ *
+ * It gives each run a workspace of the right lifetime and keeps agents out of each other's files.
+ * It does **not** contain the harness process: a determined harness can read outside its workspace,
+ * and `NetworkPolicy` is advisory here because nothing intercepts the process's sockets. Real
+ * enforcement needs the container provider, and `mcp-only` is the recommended production posture
+ * precisely because it is the one that can actually be enforced.
+ *
+ * Saying so plainly matters more than the code: an operator who believes `networkPolicy: 'none'`
+ * is enforced by this provider has a false sense of containment, which is worse than knowing the
+ * boundary is soft.
+ */
+export declare class LocalDirectorySandboxProvider implements ISandboxProvider {
+    private readonly rootPath;
+    /**
+     * @param rootPath Directory under which all workspaces are created. Defaults to a folder in the
+     *                 OS temp dir, which is fine for `run` scope but should be pointed somewhere
+     *                 durable when using `agent` or `agent-user` scopes, since temp dirs get swept.
+     */
+    constructor(rootPath?: string);
+    /** @inheritdoc */
+    Provision(key: WorkspaceKey, _config: SandboxConfig): Promise<SandboxHandle>;
+    /** @inheritdoc */
+    Finalize(handle: SandboxHandle, _outcome: 'success' | 'failure' | 'cancelled'): Promise<void>;
+    /**
+     * Maps a workspace key to a path whose shape makes the scope obvious on disk.
+     *
+     * Run-scoped paths include the run id so they are unique; durable paths deliberately do not, so
+     * the same agent (and user) reattaches to the same directory next time.
+     */
+    private buildRelativePath;
+}
+//# sourceMappingURL=LocalDirectorySandboxProvider.d.ts.map

package/dist/sandbox/LocalDirectorySandboxProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LocalDirectorySandboxProvider.d.ts","sourceRoot":"","sources":["../../src/sandbox/LocalDirectorySandboxProvider.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAGrG;;;;;;;;;;;;;;GAcG;AACH,qBAAa,6BAA8B,YAAW,gBAAgB;IAClE,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAElC;;;;OAIG;gBACgB,QAAQ,CAAC,EAAE,MAAM;IAIpC,kBAAkB;IACL,SAAS,CAAC,GAAG,EAAE,YAAY,EAAE,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC;IAazF,kBAAkB;IACL,QAAQ,CAAC,MAAM,EAAE,aAAa,EAAE,QAAQ,EAAE,SAAS,GAAG,SAAS,GAAG,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAc1G;;;;;OAKG;IACH,OAAO,CAAC,iBAAiB;CAU5B"}

package/dist/sandbox/LocalDirectorySandboxProvider.js

@@ -0,0 +1,75 @@
+import { mkdir, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { LogError } from '@memberjunction/core';
+import { ChildProcessExecutor } from './ChildProcessExecutor.js';
+/**
+ * Phase-1 sandbox: a scoped directory on the MJ server's own filesystem.
+ *
+ * ## What this does and does not protect against
+ *
+ * It gives each run a workspace of the right lifetime and keeps agents out of each other's files.
+ * It does **not** contain the harness process: a determined harness can read outside its workspace,
+ * and `NetworkPolicy` is advisory here because nothing intercepts the process's sockets. Real
+ * enforcement needs the container provider, and `mcp-only` is the recommended production posture
+ * precisely because it is the one that can actually be enforced.
+ *
+ * Saying so plainly matters more than the code: an operator who believes `networkPolicy: 'none'`
+ * is enforced by this provider has a false sense of containment, which is worse than knowing the
+ * boundary is soft.
+ */
+export class LocalDirectorySandboxProvider {
+    /**
+     * @param rootPath Directory under which all workspaces are created. Defaults to a folder in the
+     *                 OS temp dir, which is fine for `run` scope but should be pointed somewhere
+     *                 durable when using `agent` or `agent-user` scopes, since temp dirs get swept.
+     */
+    constructor(rootPath) {
+        this.rootPath = rootPath ?? join(tmpdir(), 'mj-agent-harness');
+    }
+    /** @inheritdoc */
+    async Provision(key, _config) {
+        const workspacePath = join(this.rootPath, this.buildRelativePath(key));
+        await mkdir(workspacePath, { recursive: true });
+        return {
+            WorkspacePath: workspacePath,
+            Key: key,
+            Ephemeral: key.Scope === 'run',
+            // Runs directly on the MJAPI host. The workspace path is a host path here, which is the
+            // one case where it is also safe to touch with `fs` — see the note on SandboxHandle.
+            Executor: new ChildProcessExecutor(workspacePath),
+        };
+    }
+    /** @inheritdoc */
+    async Finalize(handle, _outcome) {
+        if (!handle.Ephemeral) {
+            // Durable scopes keep their files — that is the whole point of them.
+            return;
+        }
+        try {
+            await rm(handle.WorkspacePath, { recursive: true, force: true });
+        }
+        catch (e) {
+            // Never rethrow from finalize: it runs on failure and cancellation paths, where throwing
+            // would replace the real error with a cleanup error and lose the diagnosis.
+            LogError(`Failed to remove harness workspace ${handle.WorkspacePath}: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+    /**
+     * Maps a workspace key to a path whose shape makes the scope obvious on disk.
+     *
+     * Run-scoped paths include the run id so they are unique; durable paths deliberately do not, so
+     * the same agent (and user) reattaches to the same directory next time.
+     */
+    buildRelativePath(key) {
+        switch (key.Scope) {
+            case 'run':
+                return join('run', key.RunId);
+            case 'agent':
+                return join('agent', key.AgentId);
+            case 'agent-user':
+                return join('agent-user', key.AgentId, key.UserId ?? 'no-user');
+        }
+    }
+}
+//# sourceMappingURL=LocalDirectorySandboxProvider.js.map

package/dist/sandbox/LocalDirectorySandboxProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LocalDirectorySandboxProvider.js","sourceRoot":"","sources":["../../src/sandbox/LocalDirectorySandboxProvider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,EAAE,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AACjC,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAEhD,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAEjE;;;;;;;;;;;;;;GAcG;AACH,MAAM,OAAO,6BAA6B;IAGtC;;;;OAIG;IACH,YAAmB,QAAiB;QAChC,IAAI,CAAC,QAAQ,GAAG,QAAQ,IAAI,IAAI,CAAC,MAAM,EAAE,EAAE,kBAAkB,CAAC,CAAC;IACnE,CAAC;IAED,kBAAkB;IACX,KAAK,CAAC,SAAS,CAAC,GAAiB,EAAE,OAAsB;QAC5D,MAAM,aAAa,GAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC,CAAC;QACvE,MAAM,KAAK,CAAC,aAAa,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QAChD,OAAO;YACH,aAAa,EAAE,aAAa;YAC5B,GAAG,EAAE,GAAG;YACR,SAAS,EAAE,GAAG,CAAC,KAAK,KAAK,KAAK;YAC9B,wFAAwF;YACxF,qFAAqF;YACrF,QAAQ,EAAE,IAAI,oBAAoB,CAAC,aAAa,CAAC;SACpD,CAAC;IACN,CAAC;IAED,kBAAkB;IACX,KAAK,CAAC,QAAQ,CAAC,MAAqB,EAAE,QAA6C;QACtF,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC;YACpB,qEAAqE;YACrE,OAAO;QACX,CAAC;QACD,IAAI,CAAC;YACD,MAAM,EAAE,CAAC,MAAM,CAAC,aAAa,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;QACrE,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACT,yFAAyF;YACzF,4EAA4E;YAC5E,QAAQ,CAAC,sCAAsC,MAAM,CAAC,aAAa,KAAK,CAAC,YAAY,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QAC1H,CAAC;IACL,CAAC;IAED;;;;;OAKG;IACK,iBAAiB,CAAC,GAAiB;QACvC,QAAQ,GAAG,CAAC,KAAK,EAAE,CAAC;YAChB,KAAK,KAAK;gBACN,OAAO,IAAI,CAAC,KAAK,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC;YAClC,KAAK,OAAO;gBACR,OAAO,IAAI,CAAC,OAAO,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC;YACtC,KAAK,YAAY;gBACb,OAAO,IAAI,CAAC,YAAY,EAAE,GAAG,CAAC,OAAO,EAAE,GAAG,CAAC,MAAM,IAAI,SAAS,CAAC,CAAC;QACxE,CAAC;IACL,CAAC;CACJ"}

package/dist/sandbox/SandboxExecutor.d.ts

@@ -0,0 +1,47 @@
+/**
+ * How to run one command inside a sandbox.
+ *
+ * Deliberately NOT modelled on Node's `ChildProcess`. Spawning locally and `docker exec` both
+ * happen to produce a child process, but a Kubernetes exec is streams over a websocket and a remote
+ * runner is HTTP — an interface that promised `ChildProcess` could never be implemented honestly by
+ * either. Promising async iterables of lines instead lets every backend satisfy the same contract.
+ *
+ * The second benefit is testing: a fake executor replays canned JSONL, so adapter behaviour can be
+ * unit-tested without a harness binary, a container, or a network.
+ */
+export interface HarnessProcessSpec {
+    /** Binary or command to run inside the sandbox. */
+    Command: string;
+    /** Arguments, already split — never a shell string, so nothing needs quoting or escaping. */
+    Args: string[];
+    /** Environment for the process. Exactly what the agent was granted; never the host's full env. */
+    Environment: Record<string, string>;
+    /** Working directory inside the sandbox. Defaults to the workspace root. */
+    WorkingDirectory?: string;
+    /** Aborts the process. */
+    CancellationToken?: AbortSignal;
+}
+/**
+ * A running process inside a sandbox, wherever that sandbox physically is.
+ */
+export interface HarnessProcess {
+    /** stdout as complete lines, already framed. Ends when the process closes its stream. */
+    Stdout: AsyncIterable<string>;
+    /** stderr as complete lines. Consumers typically buffer this for error reporting. */
+    Stderr: AsyncIterable<string>;
+    /** Resolves with the exit code (or null if terminated by signal) once the process has exited. */
+    ExitCode: Promise<number | null>;
+    /** Terminates the process. Must be safe to call more than once, and after exit. */
+    Kill(): void;
+}
+/**
+ * Runs commands inside a provisioned sandbox.
+ *
+ * Obtained from {@link SandboxHandle}, so the sandbox provider — not the adapter — decides WHERE a
+ * harness process runs. That separation is the whole point: `CodexAdapter` builds argv and parses
+ * events, and never learns whether it is executing on the MJAPI host, in a container, or in a pod.
+ */
+export interface SandboxExecutor {
+    Run(spec: HarnessProcessSpec): HarnessProcess;
+}
+//# sourceMappingURL=SandboxExecutor.d.ts.map

package/dist/sandbox/SandboxExecutor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SandboxExecutor.d.ts","sourceRoot":"","sources":["../../src/sandbox/SandboxExecutor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,WAAW,kBAAkB;IAC/B,mDAAmD;IACnD,OAAO,EAAE,MAAM,CAAC;IAChB,6FAA6F;IAC7F,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,kGAAkG;IAClG,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,4EAA4E;IAC5E,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,0BAA0B;IAC1B,iBAAiB,CAAC,EAAE,WAAW,CAAC;CACnC;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC3B,yFAAyF;IACzF,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC9B,qFAAqF;IACrF,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC9B,iGAAiG;IACjG,QAAQ,EAAE,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IACjC,mFAAmF;IACnF,IAAI,IAAI,IAAI,CAAC;CAChB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,eAAe;IAC5B,GAAG,CAAC,IAAI,EAAE,kBAAkB,GAAG,cAAc,CAAC;CACjD"}

package/dist/sandbox/SandboxExecutor.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=SandboxExecutor.js.map

package/dist/sandbox/SandboxExecutor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SandboxExecutor.js","sourceRoot":"","sources":["../../src/sandbox/SandboxExecutor.ts"],"names":[],"mappings":""}

package/dist/types.d.ts

@@ -0,0 +1,180 @@
+import { MJAIAgentHarnessEntity } from '@memberjunction/core-entities';
+import { SandboxExecutor } from './sandbox/SandboxExecutor.js';
+/**
+ * What a harness adapter can do, mirrored from `AIAgentHarness.CapabilitySettings`.
+ *
+ * Derived from the entity's generated JSONType accessor rather than restated here, so this stays in
+ * lockstep with the interface CodeGen emits from `IHarnessCapabilitySettings.ts`. Restating the
+ * shape by hand is the value-list drift trap in a different costume.
+ */
+export type HarnessCapabilities = NonNullable<MJAIAgentHarnessEntity['CapabilitySettingsObject']>;
+/**
+ * Everything an adapter needs to launch a harness session.
+ *
+ * Assembled once per run by {@link HarnessAgentBase} and handed to
+ * {@link BaseHarnessAdapter.StartSession}. Nothing here is re-derived per turn — a session's
+ * identity, workspace and credentials are fixed for its lifetime.
+ */
+export interface HarnessSessionConfig {
+    /**
+     * Runs harness processes inside the sandbox.
+     *
+     * Adapters MUST go through this rather than calling `spawn` themselves. An adapter that spawns
+     * directly always runs on the MJAPI host, which in production means an autonomous agent
+     * executing shell commands inside the API container with its network reach and cloud
+     * credentials — and, worse, it does so while the agent's config claims `provider: 'docker'`.
+     * Routing through the executor is what makes the sandbox choice real rather than decorative.
+     */
+    Executor: SandboxExecutor;
+    /**
+     * Workspace path AS THE HARNESS SEES IT — a host path under the local provider, a
+     * container-internal path under Docker. Pass it to harness processes; do not open it with `fs`.
+     */
+    WorkspacePath: string;
+    /**
+     * Environment variables injected into the harness process — the LLM key and any granted
+     * integration tokens resolved from `MJ: AI Agent Credentials`.
+     *
+     * This is the ONLY channel by which a secret reaches the sandbox, and it carries exactly what
+     * the agent was granted. Never DB credentials, never a user token, never a general MJ API key.
+     */
+    Environment: Record<string, string>;
+    /** MCP endpoint for the read-only intra-turn loopback; omitted when the harness has no MCP client. */
+    McpServerUrl?: string;
+    /** Per-run, read-only, scope-limited MCP credential. Revoked at teardown on every exit path. */
+    McpCredential?: string;
+    /**
+     * A prior session this run MAY continue, when one exists for the same agent and conversation.
+     *
+     * Offered, not imposed. Only adapters whose harness can genuinely resume should act on it, and
+     * they must report the outcome through {@link BaseHarnessAdapter.DidResumeSession} — because the
+     * caller sends a DIFFERENT turn input depending on whether the resume took. Guessing wrong in
+     * either direction is costly: assume resumed when it was not and the harness has no context;
+     * assume fresh when it did resume and it receives the conversation twice.
+     */
+    ResumeSessionId?: string;
+    /**
+     * What the agent may do inside the sandbox. Adapters translate this into their own flags via
+     * {@link BaseHarnessAdapter.ApplyPermissionPolicy}, or ignore it if they cannot enforce it.
+     */
+    PermissionPolicy?: HarnessPermissionPolicy;
+    /** Model to request, when the harness honours one (`CapabilitySettings.ModelSelection`). */
+    Model?: string;
+    /** Aborts in-flight work; honoured mid-turn only when `CapabilitySettings.MidTurnCancellation`. */
+    CancellationToken?: AbortSignal;
+}
+/**
+ * Events an adapter emits while a turn is in flight.
+ *
+ * Deliberately a small, closed set. Anything the harness does INSIDE its sandbox that does not
+ * cross one of these boundaries is governed by posture policy, not recorded as a run step — the
+ * opaque-super-step property of this design, which is intentional and must stay documented rather
+ * than quietly widened.
+ */
+export type HarnessTurnEvent = 
+/** Streamed narration, surfaced to `onProgress` and never persisted as a step. */
+{
+    Type: 'assistant-text';
+    Text: string;
+}
+/** Informational in-sandbox activity (file edit, shell command) for live view only. */
+ | {
+    Type: 'sandbox-activity';
+    Description: string;
+}
+/** The harness wants to do something the posture gates; becomes an `MJ: AI Agent Requests` row. */
+ | {
+    Type: 'permission-request';
+    RequestId: string;
+    Description: string;
+    Command?: string;
+}
+/** Token/cost usage for the turn. Without this the run cannot be accounted for — see below. */
+ | {
+    Type: 'usage';
+    InputTokens: number;
+    OutputTokens: number;
+    CostUsd?: number;
+}
+/** The turn ended. `RawText` is expected to carry the Loop next-step JSON envelope. */
+ | {
+    Type: 'turn-complete';
+    RawText: string;
+}
+/** The session failed. Terminal for the turn; the run decides whether to retry. */
+ | {
+    Type: 'session-error';
+    Error: string;
+};
+/**
+ * The accumulated outcome of one harness turn, assembled by {@link HarnessAgentBase} from the
+ * adapter's event stream.
+ */
+export interface HarnessTurnResult {
+    /** Raw turn-end text, handed to the Loop JSON parser exactly as a prompt response would be. */
+    RawText: string;
+    /** Summed usage for the turn. Zeros when the harness reports none — which is itself a finding. */
+    InputTokens: number;
+    OutputTokens: number;
+    CostUsd?: number;
+    /** Set when the turn failed rather than completed. */
+    ErrorMessage?: string;
+    /** Vendor session id, persisted to `AIAgentRun.ExternalSessionID` for resume and log correlation. */
+    SessionId?: string;
+    /**
+     * The model the harness ACTUALLY used, as it reported it (e.g. `claude-opus-4-6`).
+     *
+     * Distinct from the model we asked for. A harness free to pick its own model will, and recording
+     * the one we assumed instead of the one it used makes cost attribution wrong — Opus and Sonnet
+     * are not the same price.
+     */
+    ReportedModel?: string;
+}
+/** Where a harness workspace lives and how long it survives. */
+export type HarnessWorkspaceScope = 'run' | 'agent' | 'agent-user';
+/** What the sandbox may reach on the network. */
+export type HarnessNetworkPolicy = 'none' | 'mcp-only' | 'allowlist' | 'open';
+/** How much in-sandbox autonomy the harness gets before MJ interposes a human. */
+export type HarnessPosture = 'strict' | 'auto' | 'dangerous';
+/**
+ * What the agent is permitted to do inside its sandbox, expressed in MJ's vocabulary rather than
+ * any harness's.
+ *
+ * ## Why this exists as an abstraction
+ *
+ * Every harness has its own permission mechanism and its own spelling — Claude Code has
+ * `--permission-mode` with six modes plus `--allowedTools` patterns, others have none at all. Left
+ * unabstracted, permissions would be configured per-harness, and switching harnesses would silently
+ * change what an agent may do. That is the opposite of the property this whole design exists for:
+ * MJ owns authority, the harness supplies reasoning.
+ *
+ * So the posture and tool patterns are declared ONCE in agent metadata, overridable per run, and
+ * each adapter translates them into its own flags — or ignores them and reports that it cannot
+ * enforce them.
+ *
+ * ## The postures
+ *
+ * - `strict` — nothing mutating without human approval. Honest today only where an adapter can
+ *   actually intercept; where it cannot, the harness's own prompts have nowhere to go in headless
+ *   mode and every tool call simply denies. That is a real, observed outcome, not a hypothetical:
+ *   an agent asked to run `git status` across repos had all 21 calls blocked and correctly stopped
+ *   to ask for permission MJ had no way to grant.
+ * - `auto` — the harness proceeds on its own for anything inside {@link AllowedTools}, and is
+ *   refused anything in {@link DisallowedTools}. The workable default until HITL lands.
+ * - `dangerous` — no gating at all. Only defensible inside a contained sandbox; the Docker provider
+ *   with a real network policy is the intended pairing, not the local provider.
+ */
+export interface HarnessPermissionPolicy {
+    /** How much autonomy the harness gets. See the posture notes above. */
+    Posture: HarnessPosture;
+    /**
+     * Tool patterns the agent may use without asking, in the harness's own pattern language
+     * (e.g. `Bash(git:*)`, `Read`, `Grep`). Deliberately passed through rather than normalised:
+     * inventing an MJ-wide tool taxonomy would be a lossy translation of every harness's model, and
+     * the patterns are the part operators actually reason about.
+     */
+    AllowedTools?: string[];
+    /** Tool patterns the agent must never use. Takes precedence over {@link AllowedTools}. */
+    DisallowedTools?: string[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AACvE,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAE/D;;;;;;GAMG;AACH,MAAM,MAAM,mBAAmB,GAAG,WAAW,CAAC,sBAAsB,CAAC,0BAA0B,CAAC,CAAC,CAAC;AAElG;;;;;;GAMG;AACH,MAAM,WAAW,oBAAoB;IACjC;;;;;;;;OAQG;IACH,QAAQ,EAAE,eAAe,CAAC;IAC1B;;;OAGG;IACH,aAAa,EAAE,MAAM,CAAC;IACtB;;;;;;OAMG;IACH,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,sGAAsG;IACtG,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,gGAAgG;IAChG,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;;;;;OAQG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,uBAAuB,CAAC;IAC3C,4FAA4F;IAC5F,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,mGAAmG;IACnG,iBAAiB,CAAC,EAAE,WAAW,CAAC;CACnC;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,gBAAgB;AACxB,kFAAkF;AAChF;IAAE,IAAI,EAAE,gBAAgB,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE;AAC1C,uFAAuF;GACrF;IAAE,IAAI,EAAE,kBAAkB,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE;AACnD,mGAAmG;GACjG;IAAE,IAAI,EAAE,oBAAoB,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE;AAC1F,+FAA+F;GAC7F;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE;AAChF,uFAAuF;GACrF;IAAE,IAAI,EAAE,eAAe,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE;AAC5C,mFAAmF;GACjF;IAAE,IAAI,EAAE,eAAe,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAE/C;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IAC9B,+FAA+F;IAC/F,OAAO,EAAE,MAAM,CAAC;IAChB,kGAAkG;IAClG,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,sDAAsD;IACtD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,qGAAqG;IACrG,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;;;OAMG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,gEAAgE;AAChE,MAAM,MAAM,qBAAqB,GAAG,KAAK,GAAG,OAAO,GAAG,YAAY,CAAC;AAEnE,iDAAiD;AACjD,MAAM,MAAM,oBAAoB,GAAG,MAAM,GAAG,UAAU,GAAG,WAAW,GAAG,MAAM,CAAC;AAE9E,kFAAkF;AAClF,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,MAAM,GAAG,WAAW,CAAC;AAE7D;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,WAAW,uBAAuB;IACpC,uEAAuE;IACvE,OAAO,EAAE,cAAc,CAAC;IACxB;;;;;OAKG;IACH,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,0FAA0F;IAC1F,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;CAC9B"}

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/package.json

@@ -1,10 +1,37 @@
 {
   "name": "@memberjunction/ai-agent-harness",
-  "version": "0.0.0",
-  "description": "OIDC trusted publishing setup package for @memberjunction/ai-agent-harness",
-  "keywords": [
-    "oidc",
-    "trusted-publishing",
-    "setup"
-  ]
-}
+  "type": "module",
+  "version": "6.1.0-edge.2",
+  "description": "MemberJunction: External Agent Harness integration — run Claude Code, Codex, OpenCode, Gemini CLI or Pi as the reasoning substrate for an MJ agent",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "/dist"
+  ],
+  "author": "MemberJunction.com",
+  "license": "ISC",
+  "dependencies": {
+    "@memberjunction/ai": "6.1.0-edge.2",
+    "@memberjunction/ai-agents": "6.1.0-edge.2",
+    "@memberjunction/ai-core-plus": "6.1.0-edge.2",
+    "@memberjunction/core": "6.1.0-edge.2",
+    "@memberjunction/core-entities": "6.1.0-edge.2",
+    "@memberjunction/global": "6.1.0-edge.2",
+    "@memberjunction/templates": "6.1.0-edge.2"
+  },
+  "devDependencies": {
+    "@types/node": "24.10.11",
+    "typescript": "^5.4.5",
+    "tsc-alias": "^1.8.10",
+    "vitest": "^4.0.18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/MemberJunction/MJ"
+  },
+  "scripts": {
+    "build": "tsc && tsc-alias -f",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
+}