@civilization/dsh-agent-loop 0.0.0-stage → 0.2.1-rc.3

package/lib/types/agent.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Default Agent driver over queued turns and step-boundary input. Every request
+ * is derived from the session log.
+ * @module dsh-agent-loop/agent
+ */
+import type { Agent, AgentCancelCause, AgentOptions, AgentStatus, CancelOptions, InboxTarget } from '@deepseek-ai/dsh-agent';
+import type { Scope } from '@deepseek-ai/dsh-scope';
+import type { Session, SessionId, UserMessage } from '@deepseek-ai/dsh-session';
+import type { Context } from '@deepseek-ai/cordis';
+import { ReactLoopInbox } from './inbox.ts';
+/** Drives one session through turn and step boundaries. */
+export declare class ReactLoopAgent implements Agent {
+    private loopCtx;
+    readonly id: SessionId;
+    readonly options: AgentOptions;
+    readonly session: Session;
+    readonly inbox: ReactLoopInbox;
+    private phase;
+    private activityDone;
+    /** The agent-scoped registration boundary; the lifecycle owner unwinds it after the driver exits. */
+    readonly scope: Scope;
+    readonly ctx: Context;
+    /** Fused dispatcher, built once in the constructor so hot-path dispatches never allocate. */
+    private readonly dispatch;
+    /** Whether this loop instance has appended its initial/resume request anchor. */
+    private requestHeaderLogged;
+    /** Surface generation at attachment or the preceding built request. */
+    private requestSurfaceGeneration;
+    private readonly runtimeContext;
+    /** Process-local revision of assistant frames for this attached Session. */
+    private assistantStreamRevision;
+    private assistantAttemptCounter;
+    private readonly systemPrompt;
+    /** Identities fully frozen by this loop; weak references do not retain replaced history. */
+    private readonly frozenMessages;
+    constructor(loopCtx: Context, id: SessionId, options: AgentOptions, session: Session);
+    get status(): AgentStatus;
+    /** Commit a phase and publish its externally visible status transition. */
+    private setPhase;
+    send(message: UserMessage, target: InboxTarget, wakeup: boolean): void;
+    followup(input: UserMessage): void;
+    steer(input: UserMessage): void;
+    inject(input: UserMessage): void;
+    cancel(cause: AgentCancelCause, options?: CancelOptions): void;
+    runMaintenance<T>(job: (signal: AbortSignal) => Promise<T>): Promise<T>;
+    /**
+     * Start one driver, or latch its wake behind maintenance or an aborted
+     * activity. A wake sent while idle always opens its turn boundary, even
+     * when its message was cleared; only a latched replay is suppressed when
+     * the queue no longer holds the wake.
+     * @param wakeAfterAbort - the {@link send} classification, captured before
+     *   the inbox insertion so a reentrant cancel cannot reclassify it.
+     */
+    private wakeDriver;
+    whenIdle(): Promise<void>;
+    /** Report one failure at its live boundary, then preserve it for driver containment. */
+    private throwError;
+    private kick;
+    private preStep;
+    /** Whether the assembled tool schemas differ from the logged request header's. */
+    private toolsChanged;
+    /** Open one turn before claiming its first proposed step. */
+    private turn;
+    private step;
+    /** Resolve request config and bind its adapter before admitting model-visible input. */
+    private prepareRequest;
+    /** Log the resolved envelope and derive a frozen request from the admitted surface. */
+    private buildRequest;
+}
+//# sourceMappingURL=agent.d.ts.map

package/lib/types/assistant-stream.d.ts

@@ -0,0 +1,53 @@
+/** Process-local assistant attempt framing and durable stream accumulation. */
+import { LlmAttemptId, type ContentBlock, type FinishReason, type ReplayEnvelope, type StreamChunk, type TokenUsage } from '@deepseek-ai/dsh-llm';
+import type { AssistantStreamFrame } from '@deepseek-ai/dsh-agent';
+import type { SessionEventMap, SessionId, SessionSeq } from '@deepseek-ai/dsh-session';
+/** Folds one model attempt into one compact stream plus ordered transient frames. */
+export declare class AssistantStreamAttempt {
+    private readonly nextRevision;
+    readonly turn: number;
+    readonly step: number;
+    private readonly emit;
+    private readonly accumulator;
+    private readonly assembler;
+    private index;
+    private terminal;
+    /** Attempt identity unique within this Agent lifecycle. */
+    readonly attemptId: LlmAttemptId;
+    /** Whether this started attempt has emitted its terminal frame. */
+    get ended(): boolean;
+    /**
+     * @param sessionId - identity embedded only in the Agent-lifecycle-local attempt id.
+     * @param attempt - attached-Session-local attempt counter.
+     * @param nextRevision - allocates the next emitted frame revision.
+     * @param turn - durable turn owning the request.
+     * @param step - durable step owning the request.
+     * @param emit - agent-scoped notification publisher.
+     */
+    constructor(sessionId: SessionId, attempt: number, nextRevision: () => number, turn: number, step: number, emit: (frame: AssistantStreamFrame) => void);
+    /** Publish the opening marker before the first delivered chunk. */
+    start(): void;
+    /** Snapshot one chunk once, then feed durable compaction, assembly, and live publication. */
+    push(chunk: StreamChunk): void;
+    /**
+     * Publish terminal settlement after the matching durable event commits.
+     * @param eventType - durable settlement type.
+     * @param append - synchronous durable append returning its committed seq.
+     */
+    settle(eventType: 'assistant/message' | 'assistant/attempt', append: () => SessionSeq): void;
+    /** Publish abandonment when no durable attempt event can be committed. */
+    abandon(): void;
+    /** Exact compact stream for the final durable event. */
+    get stream(): SessionEventMap['assistant/attempt']['stream'];
+    /** Canonical completed-message blocks from the same chunks. */
+    blocks(): ContentBlock[];
+    /** Safe visible prefix when cancellation interrupts the attempt. */
+    interruptedBlocks(): ContentBlock[];
+    /** Latest adapter-reported usage in the stream. */
+    get usage(): TokenUsage | undefined;
+    /** Terminal reason, defaulting to stop when the stream omitted one. */
+    get finish(): FinishReason;
+    /** Replay state carried by the terminal finish record. */
+    get replayState(): ReplayEnvelope | undefined;
+}
+//# sourceMappingURL=assistant-stream.d.ts.map

package/lib/types/constants.d.ts

@@ -0,0 +1,6 @@
+/** Shared agent-loop scheduler defaults.
+ * @module dsh-agent-loop/constants
+ */
+/** Default maximum in-flight parallel-safe calls per agent step. */
+export declare const DEFAULT_MAX_PARALLEL_TOOL_CALLS = 10;
+//# sourceMappingURL=constants.d.ts.map

package/lib/types/inbox.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Driver-owned durable agent inbox projection and command facade.
+ *
+ * @module @deepseek-ai/dsh-agent-loop/inbox
+ */
+import type { MessageId } from '@deepseek-ai/dsh-llm';
+import type SessionProjectionRegistry from '@deepseek-ai/dsh-session-projection';
+import type { Session, UserMessage } from '@deepseek-ai/dsh-session';
+import type { AgentEventDispatch, Inbox as InboxContract, InboxState, InboxTarget, InboxWireState } from '@deepseek-ai/dsh-agent';
+import { z } from 'zod';
+/** Wire validation for pending agent input reconstructed from durable inbox splices. */
+export declare const inboxProjectionSchema: z.ZodReadonly<z.ZodObject<{
+    'next-turn': z.ZodReadonly<z.ZodArray<z.ZodCustom<UserMessage, UserMessage>>>;
+    'next-step': z.ZodReadonly<z.ZodArray<z.ZodCustom<UserMessage, UserMessage>>>;
+}, z.core.$strip>>;
+/** Standard fold that reconstructs pending input and rejects invalid durable splice history. */
+export declare const inboxProjectionDefinition: {
+    key: "inbox";
+    stateSchema: z.ZodReadonly<z.ZodObject<{
+        'next-turn': z.ZodReadonly<z.ZodArray<z.ZodCustom<UserMessage, UserMessage>>>;
+        'next-step': z.ZodReadonly<z.ZodArray<z.ZodCustom<UserMessage, UserMessage>>>;
+    }, z.core.$strip>>;
+    init: () => InboxState;
+    apply(state: InboxState, event: import("@deepseek-ai/dsh-session").SessionEvent): InboxState;
+    wire: {
+        viewSchema: z.ZodType<InboxWireState>;
+        view: (state: InboxState) => InboxWireState;
+    };
+    stateVersion: number;
+};
+/**
+ * Driver-owned durable Inbox implementation used by ReactLoopAgent and focused
+ * provider tests.
+ * @param projections - registry with the standard Inbox projection registered by AgentLoop.
+ * @param session - session whose durable events store pending input.
+ * @param dispatch - agent-scoped notifications for Inbox lifecycle events.
+ */
+export declare class ReactLoopInbox implements InboxContract {
+    private readonly projections;
+    private readonly session;
+    private readonly dispatch;
+    constructor(projections: SessionProjectionRegistry, session: Session, dispatch: AgentEventDispatch);
+    /** Prompts awaiting individual turns. */
+    get nextTurn(): readonly UserMessage[];
+    /** Input awaiting the next step boundary. */
+    get nextStep(): readonly UserMessage[];
+    /** Whether either pending-message list contains work. */
+    get hasPending(): boolean;
+    /** Durably cancel all pending input, clearing next-step before next-turn. */
+    clear(): void;
+    /**
+     * Remove and return the complete batch proposed for one step.
+     * @param target - whether this boundary also consumes one queued turn.
+     * @param turn - turn that will own the claimed batch.
+     * @returns next-step input followed by the queued turn, when requested.
+     */
+    claim(target: InboxTarget, turn: number): UserMessage[];
+    /**
+     * Append one message to a pending list.
+     * @param target - pending list to extend.
+     * @param message - message to append.
+     */
+    append(target: InboxTarget, message: UserMessage): void;
+    /**
+     * Prepend one message to a pending list.
+     * @param target - pending list to extend.
+     * @param message - message to prepend.
+     */
+    prepend(target: InboxTarget, message: UserMessage): void;
+    /**
+     * Replace one pending message in place.
+     * @param messageId - identity of the pending message to replace.
+     * @param newMessage - replacement message.
+     * @returns whether the message was still pending.
+     */
+    replace(messageId: MessageId, newMessage: UserMessage): boolean;
+    /**
+     * Remove one pending message.
+     * @param messageId - identity of the pending message to remove.
+     * @returns whether the message was still pending.
+     */
+    remove(messageId: MessageId): boolean;
+    /**
+     * Apply standard splice semantics and durably record the normalized result.
+     * @param target - pending list to mutate.
+     * @param start - splice position.
+     * @param deleteCount - maximum number of messages to remove.
+     * @param inserted - messages to insert at the resolved position.
+     * @returns messages removed by the splice.
+     */
+    splice(target: InboxTarget, start: number, deleteCount: number, inserted: UserMessage[]): UserMessage[];
+    /** Locate one pending identity across both owned lists. */
+    private locate;
+    /** Read the current durable projection state. */
+    private current;
+    /** Commit one normalized mutation and publish its live events. */
+    private mutate;
+}
+//# sourceMappingURL=inbox.d.ts.map

package/lib/types/index.d.ts

@@ -0,0 +1,179 @@
+/**
+ * Concrete agent-loop plugin: creates scoped ReactLoopAgents, publishes them
+ * through the agent/session registries, and owns their ordered teardown.
+ *
+ * @module @deepseek-ai/dsh-agent-loop
+ */
+import type { Volatile } from '@deepseek-ai/cosmokit';
+import { Context, Service } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+import { z as zod } from 'zod';
+import type { Agent, AgentFactory, AgentHandle, AgentOptions, CreateAgentOptions, ResumeAgentOptions, TurnBoundaryProjection } from '@deepseek-ai/dsh-agent';
+import type { SessionHeader, SessionId } from '@deepseek-ai/dsh-session';
+import { DEFAULT_MAX_PARALLEL_TOOL_CALLS } from './constants.ts';
+/** Host projection of agent turn and step boundaries. */
+export declare const turnBoundaryProjectionDefinition: {
+    key: "turnBoundary";
+    stateVersion: number;
+    stateSchema: zod.ZodType<TurnBoundaryProjection, unknown, zod.core.$ZodTypeInternals<TurnBoundaryProjection, unknown>>;
+    init: () => {
+        openTurnStartSeq: null;
+        lastStepStartSeq: null;
+        lastStepBoundary: null;
+        lastTurn: number;
+    };
+    apply: (state: NoInfer<TurnBoundaryProjection>, event: import("@deepseek-ai/dsh-session").SessionEvent) => TurnBoundaryProjection;
+};
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        agentLoop: AgentLoop;
+        /**
+         * Launcher-owned exact session identities for configured agents, keyed by
+         * the agent's config `id` and set with `ctx.provide()` before any Loader
+         * entry mounts (see {@link CONFIGURED_AGENT_IDENTITIES_KEY}). A launcher
+         * owns identity because only it knows whether the session already exists,
+         * while the `cordis.yml` row keeps the model route as ordinary patchable
+         * config. An entry with no matching key keeps its configured identity.
+         */
+        configuredAgentIdentities?: ConfiguredAgentIdentities;
+    }
+    interface Events {
+        /**
+         * A declarative agent entry failed before it could publish a live agent.
+         * Consumers that buffer work for the configured identity use this
+         * transient signal to reject that work instead of waiting forever. Normal
+         * factory teardown suppresses failures from the cancelled startup attempt.
+         * @param payload.sessionId - exact shared agent/session identity that failed startup.
+         * @param payload.error - persistence, setup, or publication failure.
+         * @mode emit
+         */
+        'agent-loop/config-start-failed'(payload: {
+            sessionId: SessionId;
+            error: unknown;
+        }): void;
+    }
+}
+export { DEFAULT_MAX_PARALLEL_TOOL_CALLS };
+/**
+ * One launcher-selected session identity for a configured agent. `resume`
+ * distinguishes rehydrating existing persisted history from creating the
+ * session fresh under that exact id, which the two config keys express as
+ * `resumeSessionId` and `sessionId`.
+ */
+export interface LauncherAgentIdentity {
+    /** Exact session id to create fresh or resume. */
+    id: SessionId;
+    /** Resume existing persisted history instead of creating the session fresh. */
+    resume: boolean;
+}
+/** Launcher-selected identities keyed by the configured agent's `id`. */
+export interface ConfiguredAgentIdentities extends Readonly<Record<string, LauncherAgentIdentity>> {
+}
+/**
+ * Context key a launcher sets before any Loader entry mounts
+ * (`ctx.provide(CONFIGURED_AGENT_IDENTITIES_KEY, identities)`) to fix
+ * configured agents' session identities without a config key, so an overlay
+ * repointing the row's model route cannot drop them.
+ */
+export declare const CONFIGURED_AGENT_IDENTITIES_KEY = "configuredAgentIdentities";
+/** Agent-loop plugin configuration. */
+export interface Config {
+    /**
+     * Maximum parallel-safe calls in flight per agent step. `1` is serial;
+     * omission defaults to {@link DEFAULT_MAX_PARALLEL_TOOL_CALLS}.
+     */
+    maxParallelToolCalls: Volatile<number>;
+    /** Agents created or resumed at plugin startup. */
+    agents: (AgentOptions & {
+        /** Stable config label used in logs and as the fresh combined-id prefix. */
+        id: string;
+        /** Optional stable identity; remounts resume its materialized history, while first use creates it fresh. */
+        sessionId?: SessionId;
+        /** Optional workspace for a fresh session. */
+        cwd?: string;
+        /** Persisted session to resume instead of creating a fresh session. */
+        resumeSessionId?: SessionId;
+    })[];
+}
+/** Concrete agent factory and driver service. */
+export declare class AgentLoop extends Service implements AgentFactory {
+    static inject: string[];
+    /** Runtime schema for declarative agents. */
+    static Config: z<{
+        agents?: Config['agents'];
+        maxParallelToolCalls?: number;
+    }, Config>;
+    /** Validated configuration owned by the agent-loop service. */
+    readonly config: Config;
+    private readonly ownership;
+    /** Plain holder prevents Cordis from re-tracing the factory's dependency context through a caller shadow. */
+    private readonly runtime;
+    constructor(ctx: Context, config: Config);
+    /** Report a contained declarative-start failure to identity-bound consumers. */
+    private reportConfiguredStartupFailure;
+    /** Restore a materialized exact config identity on remount, or create it on first use. */
+    private restoreOrCreateConfigured;
+    /** Wait for a draining same-id lifecycle to finish registry teardown. */
+    private waitForDrainingConfiguredIdentity;
+    /**
+     * Construct the driver, scope, and one memoized reverse teardown for a new
+     * agent. The teardown is registered with the factory and the owner fiber
+     * BEFORE publication, so a mid-setup unload rolls everything back; `signal`
+     * fuses caller cancellation with lifecycle teardown for setup awaits.
+     */
+    private prepare;
+    /**
+     * Create an agent and session under one caller-supplied identity, owned by
+     * the accessing fiber. Constructor-driven config calls mint a fresh combined
+     * id before entering this boundary. When a persistence backend is mounted,
+     * the session's durable identity and any seed are stored before publication.
+     * @param id - shared agent/session identity.
+     * @param options - concrete loop options.
+     * @param meta - optional fresh-session workspace metadata.
+     * @returns the published running agent.
+     */
+    create(id: SessionId, options?: AgentOptions, meta?: Pick<SessionHeader, 'cwd'>): Promise<Agent>;
+    /**
+     * Take a fresh session's write ownership when persistence is mounted.
+     * Nothing is appended here: the constructor seed (which never re-emits
+     * through `session/event`) is stored by `appendUnstoredSuffix` at the
+     * publication commit point, so a failed or cancelled validation or setup
+     * closes an unmaterialized handle and leaves no stored residue — the same
+     * id can be created again.
+     * @param session - the unpublished session to store.
+     * @param signal - optional cancellation forwarded to the backend create.
+     * @returns the owned handle and stored cursor, or `undefined` without a backend.
+     */
+    private createStoredSession;
+    /**
+     * Durably store the session events appended since the last stored cursor.
+     * Pre-publication appends (constructor seed markers, setup-window events
+     * such as delegation policy records) never re-emit through `session/event`,
+     * so publication must flush them through the handle before live events
+     * start routing into it.
+     * @param stored - the session's owned handle and stored cursor, if any.
+     * @param session - the unpublished session whose suffix is stored.
+     */
+    private appendUnstoredSuffix;
+    /**
+     * Create an owned agent on a caller-supplied session id.
+     * @param ownerCtx - caller context that structurally owns the lifecycle.
+     * @param options - identities, optional live parent, session seed/metadata, loop options, setup, and cancellation.
+     * @returns the published handle.
+     */
+    createAgent(ownerCtx: Context, options: CreateAgentOptions): Promise<AgentHandle>;
+    /** Prepare one Agent around an acquired Session, run setup, and publish it. */
+    private setupAndPublish;
+    private initializeAgent;
+    /**
+     * Resume an owned agent from the configured persistence service.
+     * @param ownerCtx - caller context that owns load, setup, and the live lifecycle.
+     * @param options - persisted identity, optional live parent, loop options, setup, and cancellation.
+     * @returns the published handle.
+     */
+    resume(ownerCtx: Context, options: ResumeAgentOptions): Promise<AgentHandle>;
+    /** Resume through an explicit persistence handle used by the deferred config path. */
+    private resumeWith;
+}
+export default AgentLoop;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/runtime-context.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Durable projection state for the two loop-owned surface messages the system
+ * prompt plugin forms: the system prompt (surface node 0 and any in-history
+ * replacement) and the dynamic runtime-context snapshot.
+ * @module @deepseek-ai/dsh-agent-loop/runtime-context
+ */
+import type { ContextFormed, ContextSnapshotSection } from '@deepseek-ai/dsh-llm';
+import type { Session, SurfaceIntent, SystemMessage, UserMessage } from '@deepseek-ai/dsh-session';
+import type { Context } from '@deepseek-ai/cordis';
+declare module '@deepseek-ai/dsh-llm' {
+    interface MessageSourceMap {
+        'runtime-context': {
+            kind: 'runtime-context';
+        } & ContextFormed;
+    }
+}
+/** One uncommitted system-prompt surface operation for request admission or reconciliation. */
+export interface SystemPromptCommit {
+    /** Rendered prompt or empty content: an empty head records no prompt; empty tails are dormant. */
+    message: SystemMessage;
+    /** `append` for a new system node, otherwise a replacement of one surviving system node. */
+    intent: SurfaceIntent<'system/message'>;
+}
+/** The request-series facts one prompt decision is made under. */
+export interface SystemPromptDecisionInput {
+    /** Whether the prepared route for this attempt reads a later `system` message as the effective prompt. */
+    inHistory: boolean;
+    /**
+     * Whether prompt admission must consolidate: a pre-step listener declared a
+     * new series, the surface changed since the last request, or assembled tools
+     * changed on a route without tool-update support.
+     */
+    startsSeries: boolean;
+}
+/**
+ * Decides how a rendered system prompt reaches the surface without owning the
+ * commit. The first prompt, even empty, reserves surface node 0.
+ * A capable continuing series appends changed nonempty text after the
+ * cached history. An incapable route, broken series, or cleared prompt instead
+ * normalizes the first system node and empties later active nodes. Dormant empty
+ * tails do not supply effective text or require repeated replacements.
+ */
+export declare class SystemPromptProjection {
+    private readonly session;
+    constructor(session: Session);
+    /** The surviving `system/message` nodes in surface order. */
+    private systemNodes;
+    /**
+     * Reconcile effective text and retained nodes with the prepared route and series.
+     * @param rendered - the fully rendered system prompt; `''` when none is active.
+     * @param input - the route capability and series facts for this step.
+     * @returns ordered per-node updates; an empty list means no update is needed.
+     */
+    project(rendered: string, input: SystemPromptDecisionInput): SystemPromptCommit[];
+    private replace;
+}
+/** Tracks the last retained runtime-context snapshot without owning its commit. */
+export declare class RuntimeContextProjection {
+    /** `undefined` means no snapshot ever existed; `null` means none is retained. */
+    private retained;
+    /**
+     * Restore projection state once, then follow authoritative session events.
+     * @param ctx - agent-scoped event context.
+     * @param session - session receiving projected messages.
+     */
+    constructor(ctx: Context, session: Session);
+    /**
+     * Create an uncommitted snapshot only when the retained value differs.
+     * @param current - fully rendered dynamic context.
+     * @param sections - named contributions that formed the current snapshot.
+     * @returns a candidate user message, or `undefined` when no update is needed.
+     */
+    project(current: string, sections: readonly ContextSnapshotSection[]): UserMessage | undefined;
+}
+//# sourceMappingURL=runtime-context.d.ts.map

package/lib/types/tool-calls.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Schedules one assistant step's tool calls. Exclusive calls form barriers;
+ * parallel calls use a bounded rolling pool and are reclassified before start.
+ * Dispatch may overlap, while policy, results, and result context remain
+ * model-ordered. Abort or an internal scheduler failure stops replenishment
+ * and drains started calls.
+ *
+ * Abort records synthetic error results for skipped calls so replay stays
+ * valid. A terminal scheduler failure rejects after draining; the owning step
+ * records conservative recovery results before closing.
+ * @module dsh-agent-loop/tool-calls
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import { type ToolCallBlock } from '@deepseek-ai/dsh-llm';
+import type { UserMessage } from '@deepseek-ai/dsh-session';
+/**
+ * Schedule one assistant step's tool calls by their live concurrency mode.
+ * Ordinary completion and abort commit started-call results in order. Abort
+ * drains them, records synthetic results for unstarted calls, and returns with
+ * the signal still aborted after accepting started-call context through the
+ * caller-supplied acceptor (the machine stages it in its next-step inbox for the
+ * step boundary). An internal scheduler failure stops new dispatches, drains
+ * already-started dispatches, and rejects with the first failure. The owning
+ * step supplies error results for requests without a committed outcome.
+ * The committed step's AgentLoop driver boundary supplies the initiating Agent
+ * that becomes each explicit {@link ToolExecutionInput.agent}.
+ *
+ * @param ctx - loop context that owns the tool registry and carries the initiating Agent.
+ * @param turn - current turn number.
+ * @param step - current step number.
+ * @param toolCalls - assistant calls in model order.
+ * @param signal - abort signal shared by the step.
+ * @param acceptContext - accepts committed result context for the next step boundary.
+ */
+export declare function executeToolCalls(ctx: Context, turn: number, step: number, toolCalls: ToolCallBlock[], signal: AbortSignal, acceptContext: (context: UserMessage) => void): Promise<{
+    concluded: boolean;
+}>;
+//# sourceMappingURL=tool-calls.d.ts.map

package/locale/en.json

@@ -0,0 +1,5 @@
+{
+  "meta": {
+    "title": "agent-loop"
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "智能体运行循环",
+    "description": "协调模型请求、工具调用和后续步骤，推进智能体任务。"
+  }
+}

package/package.json

@@ -1,6 +1,61 @@
 {
   "name": "@civilization/dsh-agent-loop",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "description": "The concrete agent loop plugin for the DeepSeek Harness",
+  "version": "0.2.1-rc.3",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/core/agent-loop"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./package.json": "./package.json",
+    "./locale/*.json": "./locale/*.json"
+  },
+  "files": [
+    "locale/*.json",
+    "lib/index.js",
+    "lib/types/**/*.d.ts"
+  ],
+  "license": "MIT",
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "~4.0.5",
+    "@deepseek-ai/dsh-agent": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-llm": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-scope": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-session": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-session-persistence": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-session-projection": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-system-prompt": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-tools": "0.2.1-rc.2"
+  },
+  "dependencies": {
+    "@deepseek-ai/dsh-brand": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-util-values": "0.2.1-rc.2",
+    "@deepseek-ai/schemastery": "~3.18.5",
+    "zod": "4.4.3"
+  },
+  "devDependencies": {
+    "@deepseek-ai/dsh-llm-deepseek-api-key": "0.2.1-rc.2",
+    "@deepseek-ai/cordis": "~4.0.5",
+    "@deepseek-ai/dsh-llm-pi-ai": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-agent": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-llm": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-scope": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-session": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-session-persistence": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-session-persistence-jsonl": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-session-projection": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-system-prompt": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-tools": "0.2.1-rc.2"
+  }
 }