@archmax-ai/harness 0.0.0

package/dist/core/code-description.d.ts

@@ -0,0 +1,22 @@
+/**
+ * `archmax_run` scripts carry their human-facing contract as a leading JSDoc
+ * block comment — the code-file analogue of a case file's `description`. Admin
+ * UIs display only that description. Lifecycle hook scripts are NOT covered by this convention:
+ * they are hand-authored files whose only validation is that the referenced
+ * file exists. This module is the canonical extractor so consumers never
+ * scrape comments themselves. It operates on source strings only (callers read
+ * the file through their configured backend) and never touches the filesystem.
+ */
+/** Description frontmatter extracted from a code file's leading JSDoc block. */
+export interface CodeDescription {
+    /** Human-language prose of the block, with comment decorations removed. */
+    description: string;
+}
+/**
+ * Extract the description frontmatter from a code file's source. Returns the
+ * prose of a leading JSDoc block — BOM/CRLF normalized, `*` gutters stripped,
+ * and truncated at the first `@tag` line (tags are permitted but not part of
+ * the description) — or `null` when the source does not begin with a JSDoc
+ * block or the block contains no prose.
+ */
+export declare function parseCodeDescription(source: string): CodeDescription | null;

package/dist/core/code-description.js

@@ -0,0 +1,38 @@
+/**
+ * `archmax_run` scripts carry their human-facing contract as a leading JSDoc
+ * block comment — the code-file analogue of a case file's `description`. Admin
+ * UIs display only that description. Lifecycle hook scripts are NOT covered by this convention:
+ * they are hand-authored files whose only validation is that the referenced
+ * file exists. This module is the canonical extractor so consumers never
+ * scrape comments themselves. It operates on source strings only (callers read
+ * the file through their configured backend) and never touches the filesystem.
+ */
+/**
+ * A JSDoc block comment as the first non-whitespace content of the file. The
+ * negative lookahead rejects the degenerate empty comment (slash-star-star-
+ * slash), which opens with the same three characters but has no body.
+ */
+const LEADING_JSDOC = /^\/\*\*(?!\/)([\s\S]*?)\*\//;
+/**
+ * Extract the description frontmatter from a code file's source. Returns the
+ * prose of a leading JSDoc block — BOM/CRLF normalized, `*` gutters stripped,
+ * and truncated at the first `@tag` line (tags are permitted but not part of
+ * the description) — or `null` when the source does not begin with a JSDoc
+ * block or the block contains no prose.
+ */
+export function parseCodeDescription(source) {
+    const normalized = String(source).replace(/^\uFEFF/, "").replace(/\r\n/g, "\n");
+    const match = LEADING_JSDOC.exec(normalized.trimStart());
+    if (!match)
+        return null;
+    const proseLines = [];
+    for (const rawLine of match[1].split("\n")) {
+        const line = rawLine.replace(/^\s*\** ?/, "").trimEnd();
+        if (line.startsWith("@"))
+            break;
+        proseLines.push(line);
+    }
+    const description = proseLines.join("\n").trim();
+    return description === "" ? null : { description };
+}
+//# sourceMappingURL=code-description.js.map

package/dist/core/code-description.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-description.js","sourceRoot":"","sources":["../../src/core/code-description.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAQH;;;;GAIG;AACH,MAAM,aAAa,GAAG,6BAA6B,CAAC;AAEpD;;;;;;GAMG;AACH,MAAM,UAAU,oBAAoB,CAAC,MAAc;IACjD,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;IAChF,MAAM,KAAK,GAAG,aAAa,CAAC,IAAI,CAAC,UAAU,CAAC,SAAS,EAAE,CAAC,CAAC;IACzD,IAAI,CAAC,KAAK;QAAE,OAAO,IAAI,CAAC;IAExB,MAAM,UAAU,GAAa,EAAE,CAAC;IAChC,KAAK,MAAM,OAAO,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;QAC3C,MAAM,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC;QACxD,IAAI,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC;YAAE,MAAM;QAChC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACxB,CAAC;IAED,MAAM,WAAW,GAAG,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC;IACjD,OAAO,WAAW,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC;AACrD,CAAC"}

package/dist/core/deepagents.d.ts

@@ -0,0 +1,183 @@
+import { AIMessage } from "@langchain/core/messages";
+import type { ToolMessage } from "@langchain/core/messages";
+import type { RunnableConfig } from "@langchain/core/runnables";
+import type { Graph } from "@langchain/core/runnables/graph";
+import type { StructuredTool } from "@langchain/core/tools";
+import type { AgentMiddleware, BuiltInState, ModelRequest, Runtime, ToolCallHandler, ToolCallRequest } from "langchain";
+import type { DeepAgent } from "deepagents";
+import type { WorkflowStateFields } from "../workflow/state.js";
+/**
+ * The single typed seam between this runtime and its agent framework
+ * (`deepagents` / `langchain` / `langgraph`). Every place the runtime reaches
+ * into a framework request object, drives the Deep Agent graph, or introspects a
+ * compiled graph does so through the aliases and helpers defined here — so a
+ * framework reshape surfaces at `tsc` in this module (and its call sites) rather
+ * than at runtime. Keep it thin: aliases over the framework's own generics plus
+ * a couple of narrowing helpers, not a re-abstraction of the framework.
+ *
+ * This is the only runtime module permitted to depend on the framework's
+ * middleware/introspection seam types.
+ */
+/**
+ * Agent state the workflow middleware sees on every framework request: the
+ * checkpointed workflow fields (derived once from the zod `workflowStateSchema`)
+ * intersected with the framework's built-in agent state (messages, etc.).
+ */
+export type WorkflowRequestState = WorkflowStateFields & BuiltInState & Record<string, unknown>;
+/** A model-call request carrying the workflow state (for `wrapModelCall`). */
+export type ModelCallRequest = ModelRequest<WorkflowRequestState>;
+/**
+ * The structured-output result the framework's model handler returns when the
+ * agent was assembled with a `responseFormat` — a plain object, not a message.
+ */
+export interface StructuredModelResult {
+    structuredResponse: unknown;
+    messages: unknown[];
+}
+/**
+ * What a `wrapModelCall` handler may hand back, and therefore what a middleware
+ * may return: a settled `AIMessage`, a LangGraph `Command`, or a
+ * {@link StructuredModelResult}. `Command` is typed structurally by the one field
+ * the framework's own `isCommand` duck-types on, so this seam does not depend on
+ * a `Command` class identity that a second copy of `@langchain/langgraph` would
+ * break.
+ */
+export type ModelCallResult = AIMessage | {
+    lg_name: "Command";
+} | StructuredModelResult;
+/**
+ * What a `wrapModelCall` hook must be *declared* to return. The framework's own
+ * hook type names only `AIMessage | Command`, while its agent node additionally
+ * accepts (and its own base handler produces) a {@link StructuredModelResult} —
+ * so this alias tracks the declaration and {@link asModelCallResult} bridges the
+ * gap in one place instead of at every middleware.
+ */
+export type ModelCallHookResult = Awaited<ReturnType<NonNullable<AgentMiddleware["wrapModelCall"]>>>;
+/**
+ * The handler that runs the model for a (possibly modified) request. The
+ * workflow middleware forwards its request through this to invoke the model.
+ */
+export type ModelCallHandler = (request: ModelCallRequest) => ModelCallResult | Promise<ModelCallResult>;
+/** A tool-call request carrying the workflow state (for `wrapToolCall`). */
+export type WorkflowToolCallRequest = ToolCallRequest<WorkflowRequestState>;
+/** The handler that executes a (possibly modified) tool call. */
+export type WorkflowToolCallHandler = ToolCallHandler<WorkflowRequestState>;
+/**
+ * A generic tool-call request for middleware that declares no state schema
+ * (e.g. the evals tool-mock middleware). The optional `config` mirror is a
+ * defensive fallback for runtimes that surface `configurable` under `config`
+ * instead of `runtime`.
+ */
+export type AnyToolCallRequest = ToolCallRequest & {
+    config?: {
+        configurable?: Record<string, unknown>;
+    };
+};
+/** A generic model-call request for middleware that declares no state schema. */
+export type AnyModelCallRequest = ModelRequest;
+/** The handler that executes a (possibly modified) generic tool call. */
+export type AnyToolCallHandler = ToolCallHandler;
+/** The handler that runs the model for a generic model-call request. */
+export type AnyModelCallHandler = (request: AnyModelCallRequest) => ModelCallResult | Promise<ModelCallResult>;
+/** The framework runtime handed to lifecycle hooks (context, configurable, signal, store). */
+export type FrameworkRuntime = Runtime;
+export type { ToolMessage };
+/**
+ * Bridge the framework's tool-surface type (`(ServerTool | ClientTool)[]`) to
+ * the `StructuredTool[]` the runtime works with. The runtime only ever binds
+ * `StructuredTool`s, so this narrowing is sound; confining it here keeps the one
+ * tool-surface cast out of the middleware.
+ */
+export declare function asStructuredTools(tools: ModelCallRequest["tools"] | undefined): StructuredTool[];
+/**
+ * Narrow what a `wrapModelCall` handler returned to the framework's contract.
+ *
+ * The agent node validates each middleware's *return* value, so when the model
+ * handler below the stack yields something outside the contract, the innermost
+ * middleware is the one named — even though it only forwarded the value. An
+ * `AIMessage`, a `Command` or a {@link StructuredModelResult} passes through; a
+ * value that is an assistant message in all but class identity is rebuilt into a
+ * real `AIMessage`; anything else is refused with the shape it actually had,
+ * naming the model rather than the middleware.
+ */
+export declare function asModelCallResult(result: unknown, origin: string): ModelCallHookResult;
+/**
+ * The `recursionLimit` a turn runs under when the caller names none. One invoke
+ * is one whole turn across states — every hook, model call and tool batch is a
+ * super-step — so this is generous by design: the authored budgets
+ * (`budget.maxTurns`, `maxParks`) are the real bound, and this only stops a
+ * run nothing else bounds.
+ */
+export declare const DEFAULT_RECURSION_LIMIT = 400;
+/** The input a Deep Agent graph is invoked with: messages plus any state channel. */
+export type AgentInput = Parameters<DeepAgent["invoke"]>[0];
+/** The settled state a Deep Agent graph resolves to. */
+export type AgentResult = Awaited<ReturnType<DeepAgent["invoke"]>>;
+/** The options object accepted by a Deep Agent graph's `stream`. */
+export type AgentStreamOptions = Parameters<DeepAgent["stream"]>[1];
+/**
+ * The compiled graph an assembly is built over: the Deep Agent's own
+ * `CompiledStateGraph` — a real Pregel runnable — so the surface below is the
+ * framework's own, not a re-abstraction. Declared structurally because the
+ * governed and plain graphs' state generics differ while their runtime surface
+ * is identical; the runtime only ever drives them through these members.
+ */
+export interface CompiledAgentGraph {
+    invoke(input: AgentInput, config?: RunnableConfig): Promise<AgentResult>;
+    stream(input: AgentInput, options?: AgentStreamOptions): Promise<AsyncIterable<unknown>>;
+    streamEvents(input: AgentInput, config: RunnableConfig, options?: unknown): AsyncIterable<unknown>;
+    withConfig(config: RunnableConfig): CompiledAgentGraph;
+    getState(config: RunnableConfig, options?: unknown): Promise<unknown>;
+    getStateHistory(config: RunnableConfig, options?: unknown): AsyncIterableIterator<unknown>;
+    updateState(config: RunnableConfig, values: unknown, asNode?: string): Promise<RunnableConfig>;
+    getSubgraphs(namespace?: string, recurse?: boolean): Generator<[string, unknown]>;
+    getSubgraphsAsync(namespace?: string, recurse?: boolean): AsyncGenerator<[string, unknown]>;
+    getGraphAsync(config?: RunnableConfig): Promise<Graph>;
+    checkpointer?: unknown;
+    store?: unknown;
+}
+/**
+ * Narrow a compiled graph to {@link CompiledAgentGraph}. The governed and plain
+ * graphs' declared state generics differ, so neither is assignable to a shared
+ * type by structure alone; at run time both are the same `CompiledStateGraph`
+ * class, and this is the one place that fact is asserted.
+ */
+export declare function asCompiledAgentGraph(graph: unknown): CompiledAgentGraph;
+/** Minimal shape needed to serialize a compiled LangGraph runnable's topology. */
+export interface IntrospectableGraph {
+    getGraphAsync(config: RunnableConfig): Promise<Graph>;
+}
+/**
+ * The narrow view of a compiled state graph the human-decision surface needs:
+ * read a parked session's checkpoint (`getState`) and resume it (`invoke`).
+ */
+export interface IntrospectableStateGraph {
+    getState(config: unknown): Promise<{
+        values?: Record<string, unknown>;
+        tasks?: {
+            interrupts?: unknown[];
+        }[];
+    }>;
+    invoke(input: unknown, config: unknown): Promise<Record<string, unknown>>;
+}
+/**
+ * The compiled state-graph methods the decision surface calls. The signatures
+ * are intentionally permissive (`...args: never[]`) so this gates on the methods
+ * *existing* rather than on their exact generic variance: a framework that drops
+ * or renames `getState`/`invoke` fails at the call site, while a benign
+ * parameter-type reshape does not produce noise. The exact call shapes are
+ * enforced inside {@link decide} against {@link IntrospectableStateGraph}.
+ */
+export interface DecisionGraphSource {
+    getState(...args: never[]): unknown;
+    invoke(...args: never[]): unknown;
+}
+/**
+ * Narrow a compiled state graph to {@link IntrospectableStateGraph}. The single
+ * remaining framework cast lives here (design D3): the compiled graph's
+ * `getState`/`invoke` are structurally compatible but their generic
+ * input/return types do not unify with the narrow introspection shape without
+ * widening. Containing the cast in one place keeps every call site typed against
+ * {@link DecisionGraphSource}.
+ */
+export declare function asDecisionGraph(graph: DecisionGraphSource): IntrospectableStateGraph;

package/dist/core/deepagents.js

@@ -0,0 +1,128 @@
+import { AIMessage } from "@langchain/core/messages";
+/**
+ * Bridge the framework's tool-surface type (`(ServerTool | ClientTool)[]`) to
+ * the `StructuredTool[]` the runtime works with. The runtime only ever binds
+ * `StructuredTool`s, so this narrowing is sound; confining it here keeps the one
+ * tool-surface cast out of the middleware.
+ */
+export function asStructuredTools(tools) {
+    return (tools ?? []);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function isStructuredModelResult(value) {
+    return isRecord(value) && "structuredResponse" in value && "messages" in value;
+}
+/** The framework's own `Command` test: a duck-typed `lg_name` marker. */
+function isCommandLike(value) {
+    return isRecord(value) && value.lg_name === "Command";
+}
+/**
+ * An AI message in all but class identity: a plain object that *says* it is the
+ * assistant's turn — LangChain's `type: "ai"` (an `AIMessage` built against a
+ * second copy of `@langchain/core`, whose brand this copy does not recognize) or
+ * the chat protocol's `role: "assistant"` (a provider dict) — with `content` the
+ * framework accepts. A message that names no role is not repaired here: the
+ * provider seam (`createChatModel` in `env.ts`) reads a role-less response as the
+ * assistant's before it reaches the agent loop.
+ */
+function asAiMessageLike(value) {
+    if (!isRecord(value))
+        return undefined;
+    const { content } = value;
+    if (typeof content !== "string" && !Array.isArray(content))
+        return undefined;
+    const declaredType = typeof value._getType === "function" ? value._getType() : value.type;
+    const isAi = declaredType === "ai" || value.role === "assistant";
+    return isAi ? value : undefined;
+}
+/**
+ * Narrow what a `wrapModelCall` handler returned to the framework's contract.
+ *
+ * The agent node validates each middleware's *return* value, so when the model
+ * handler below the stack yields something outside the contract, the innermost
+ * middleware is the one named — even though it only forwarded the value. An
+ * `AIMessage`, a `Command` or a {@link StructuredModelResult} passes through; a
+ * value that is an assistant message in all but class identity is rebuilt into a
+ * real `AIMessage`; anything else is refused with the shape it actually had,
+ * naming the model rather than the middleware.
+ */
+export function asModelCallResult(result, origin) {
+    if (AIMessage.isInstance(result) || isCommandLike(result) || isStructuredModelResult(result)) {
+        // The one widening cast: a structured-output result is outside the framework's
+        // declared hook return type but inside what its agent node accepts.
+        return result;
+    }
+    const messageLike = asAiMessageLike(result);
+    if (messageLike) {
+        return new AIMessage({
+            content: messageLike.content,
+            ...(messageLike.tool_calls ? { tool_calls: messageLike.tool_calls } : {}),
+            ...(messageLike.invalid_tool_calls
+                ? { invalid_tool_calls: messageLike.invalid_tool_calls }
+                : {}),
+            ...(messageLike.additional_kwargs ? { additional_kwargs: messageLike.additional_kwargs } : {}),
+            ...(messageLike.response_metadata ? { response_metadata: messageLike.response_metadata } : {}),
+            ...(messageLike.usage_metadata ? { usage_metadata: messageLike.usage_metadata } : {}),
+            ...(messageLike.id ? { id: messageLike.id } : {}),
+            ...(messageLike.name ? { name: messageLike.name } : {}),
+        });
+    }
+    throw new Error(`The model call in '${origin}' returned ${describeModelResult(result)}, which is neither ` +
+        `an AIMessage, a Command, nor a structured-output result. The value comes from the model ` +
+        `(or from a middleware assembled inside this one), not from workflow governance — check ` +
+        `the configured chat model and its provider response.`);
+}
+/**
+ * A short, non-leaking description of a rejected model result. Names the message
+ * kind (LangChain's `type`, and the class it arrived as) when the value is
+ * message-shaped — that is what identifies which turn a provider claimed.
+ */
+function describeModelResult(result) {
+    if (result === null)
+        return "null";
+    if (result === undefined)
+        return "undefined";
+    if (!isRecord(result))
+        return `a ${typeof result}`;
+    const keys = Object.keys(result);
+    const shown = keys.slice(0, 8).join(", ");
+    const shape = `a plain object with keys [${shown}${keys.length > 8 ? ", …" : ""}]`;
+    const kind = typeof result.type === "string" ? `type '${result.type}'` : undefined;
+    const className = typeof result.constructor === "function" && result.constructor.name !== "Object"
+        ? result.constructor.name
+        : undefined;
+    const named = [kind, className].filter(Boolean).join(", ");
+    return named === "" ? shape : `${shape} (${named})`;
+}
+// --- Defaults -----------------------------------------------------------------
+/**
+ * The `recursionLimit` a turn runs under when the caller names none. One invoke
+ * is one whole turn across states — every hook, model call and tool batch is a
+ * super-step — so this is generous by design: the authored budgets
+ * (`budget.maxTurns`, `maxParks`) are the real bound, and this only stops a
+ * run nothing else bounds.
+ */
+export const DEFAULT_RECURSION_LIMIT = 400;
+/**
+ * Narrow a compiled graph to {@link CompiledAgentGraph}. The governed and plain
+ * graphs' declared state generics differ, so neither is assignable to a shared
+ * type by structure alone; at run time both are the same `CompiledStateGraph`
+ * class, and this is the one place that fact is asserted.
+ */
+export function asCompiledAgentGraph(graph) {
+    return graph;
+}
+/**
+ * Narrow a compiled state graph to {@link IntrospectableStateGraph}. The single
+ * remaining framework cast lives here (design D3): the compiled graph's
+ * `getState`/`invoke` are structurally compatible but their generic
+ * input/return types do not unify with the narrow introspection shape without
+ * widening. Containing the cast in one place keeps every call site typed against
+ * {@link DecisionGraphSource}.
+ */
+export function asDecisionGraph(graph) {
+    return graph;
+}
+//# sourceMappingURL=deepagents.js.map

package/dist/core/deepagents.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deepagents.js","sourceRoot":"","sources":["../../src/core/deepagents.ts"],"names":[],"mappings":"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"}