@archships/dim-agent-sdk 0.0.3 → 0.0.5

package/README.md

@@ -34,8 +34,16 @@ const session = await agent.createSession({
   systemPrompt: 'You are a coding agent. Use tools when needed.',
 })
 
-const message = await session.send('Create hello.txt in the current directory and write hello world into it.')
-console.log(message.content)
+const itemId = session.send('Create hello.txt in the current directory and write hello world into it.')
+
+for await (const event of session.receive()) {
+  if (event.itemId !== itemId)
+    continue
+  if (event.type === 'text_delta')
+    process.stdout.write(event.delta)
+  if (event.type === 'done')
+    console.log(event.message.content)
+}
 ```
 
 ## Manual
@@ -48,8 +56,9 @@ console.log(message.content)
 
 - Canonical content / message / tool / model / state contracts
 - `createAgent()` -> `Agent` -> `Session`
-- Session stream events: `text_delta`, optional `thinking_delta`, `tool_call`, `plugin_event`, `tool_result`, `done`
-- Provider adapters: `openai-compatible`, `openai-responses`, `anthropic`, `gemini`
+- Queue-first session flow: `send()`, `sendBatch()`, `steer()`, `receive()`, `getQueueStatus()`
+- Session events: `text_delta`, optional `thinking_delta`, `tool_call`, `plugin_event`, `tool_result`, `done`, `error`
+- Provider adapters: `openai-compatible`, `openai-responses`, `anthropic`, `gemini`, `zenmux`, `aihubmix`, `aihubmix-responses`, `moonshotai`, `deepseek`, `xai`, `xai-responses`
 - Builtin tools: `read`, `write`, `edit`, `exec`
 - Hook-first plugin integration
 - Runtime gateways: file system, git, exec, network, model
@@ -109,8 +118,20 @@ Current failure policy:
 
 - `createOpenAIAdapter()`: OpenAI-compatible Chat Completions style; no official reasoning channel mapping
 - `createOpenAIResponsesAdapter()`: official OpenAI Responses API; maps reasoning summaries into `thinking_delta`
-- `createAnthropicAdapter()`: maps Claude thinking blocks into `thinking_delta`
+- `createAnthropicAdapter()`: maps Claude thinking blocks into `thinking_delta`; when overriding `baseUrl`, the adapter appends `/v1` if it is missing
 - `createGeminiAdapter()`: maps Gemini thought parts into `thinking_delta`
+- `createZenMuxAdapter()`: ZenMux chat adapter; keeps ZenMux-native `reasoningEffort`
+- `createAihubmixAdapter()` / `createAihubmixResponsesAdapter()`: AIHubMix chat + responses adapters; `responses` keeps `previousResponseId`. If you omit `apiKey`, you must inject the real upstream authentication inside custom `fetch`.
+- `createMoonshotAIAdapter()`: MoonshotAI language model adapter with thinking budget mapping
+- `createDeepSeekAdapter()`: DeepSeek chat adapter with reasoning -> `thinking_delta`
+- `createXaiAdapter()` / `createXaiResponsesAdapter()`: xAI chat + responses adapters; `responses` keeps `previousResponseId`
+- Builtin providers are also available from public subpaths such as `@archships/dim-agent-sdk/providers/openai` and `@archships/dim-agent-sdk/providers/xai-responses`
+- Other deep internal imports are not part of the public API, even though package-local tests use path aliases against `src/*`
+- Custom providers can follow the same factory pattern via `@archships/dim-agent-sdk/providers/core`
+
+```ts
+import { createProviderFactory } from '@archships/dim-agent-sdk/providers/core'
+```
 
 ## Demo
 
@@ -175,6 +196,7 @@ The provider smoke layer reuses:
 
 - `DIM_TEST_API_KEY`
 - `DIM_TEST_BASE_URL`
+- `DIM_TEST_BASE_URL_ANTHROPIC` (optional; enables the Anthropic smoke lane)
 - `DIM_TEST_MODEL_ID` (optional)
 
 Smoke tests assert stable invariants such as tool calls, `plugin_event`, notifications, and on-disk side effects. They intentionally avoid exact natural-language output matching.

package/dist/dim-agent-sdk/src/agent-core/agent-types.d.ts

@@ -1,9 +1,9 @@
 import type { DimPlugin } from '@archships/dim-plugin-api';
-import type { CompactionOptions, Message, MessageContentInput, ModelClient, Tool } from '../contracts';
+import type { CompactionOptions, Message, MessageContentInput, MessageQueueConfig, ModelClient, Tool } from '../contracts';
 import type { ContextManager } from '../context';
 import type { StateStore } from '../persistence/store';
 import type { PermissionSpec } from '../services';
-import type { ToolRegistry } from '../tools/ToolRegistry';
+import type { ToolRegistry } from '../tools/tool-registry';
 import type { ApprovalHandler } from './approvals';
 export interface AgentOptions {
     model: ModelClient;
@@ -26,4 +26,5 @@ export interface CreateSessionOptions {
     metadata?: Record<string, unknown>;
     messages?: Message[];
     systemPrompt?: MessageContentInput;
+    messageQueueConfig?: Partial<MessageQueueConfig>;
 }

package/dist/dim-agent-sdk/src/agent-core/{Agent.d.ts → agent.d.ts}

@@ -1,11 +1,11 @@
 import type { DimPlugin } from '@archships/dim-plugin-api';
 import type { SessionSnapshot } from '../contracts';
 import type { StateStore } from '../persistence/store';
-import { PluginHost } from '../plugin-host/PluginHost';
+import { PluginHost } from '../plugin-host/plugin-host';
 import type { AgentServices, PermissionSpec } from '../services';
 import { ToolRegistry } from '../tools';
 import type { ApprovalHandler } from './approvals';
-import { Session } from './Session';
+import { Session } from './session';
 import type { AgentOptions, CreateSessionOptions } from './agent-types';
 export declare class Agent {
     readonly id: string;

package/dist/dim-agent-sdk/src/agent-core/index.d.ts

@@ -1,20 +1,20 @@
-export { Agent, createAgent } from './Agent';
+export { Agent, createAgent } from './agent';
 export type { ApprovalContext, ApprovalHandler, ApprovalManager } from './approvals';
 export { DefaultCompactionService, applyCompactionUpdate, buildCompactionPromptSegments, calculateThresholdTokens, clearCompactionState, cloneCompactionState, createEmptyCompactionState, didCompactionStateChange, estimateCompactionBudget, isCompactionRequired, normalizeCompactionState, projectMessagesForRequest, } from './compaction';
 export { DefaultPluginStateService, clonePluginSessionStateEntry, clonePluginStateMap, normalizePluginStateMap, } from './plugin-state';
-export { createModel } from './createModel';
+export { createModel } from './create-model';
 export { DefaultApprovalManager } from './approvals';
 export { DefaultNotificationBus } from './notifications';
-export { Session } from './Session';
+export { Session } from './session';
 export { SessionExecutionError } from './errors';
 export type { AgentOptions, CreateSessionOptions } from './agent-types';
-export type { CreateAgentOptions } from './Agent';
-export type { LoopRunnerDependencies, LoopRunnerRunOptions } from './LoopRunner';
-export type { CreateAssistantMessageInput, MessageFactory } from './MessageFactory';
-export type { CollectModelTurnOptions, ModelTurnCollector, ModelTurnResult } from './ModelTurnCollector';
+export type { CreateAgentOptions } from './agent';
+export type { LoopRunnerDependencies, LoopRunnerRunOptions } from './loop-runner';
+export type { CreateAssistantMessageInput, MessageFactory } from './message-factory';
+export type { CollectModelTurnOptions, ModelTurnCollector, ModelTurnResult } from './model-turn-collector';
 export type { NotificationBus, NotificationContext } from './notifications';
 export type { RuntimeSessionState } from './session-state';
-export type { SessionOptions } from './Session';
+export type { SessionOptions } from './session';
 export type { SubagentInvocation, SubagentResult, SubagentRuntime } from './subagent';
-export type { TerminationDecision, TerminationPolicy } from './TerminationPolicy';
-export type { ToolExecutor, ToolExecutorExecuteOptions, ToolExecutorOptions } from './ToolExecutor';
+export type { TerminationDecision, TerminationPolicy } from './termination-policy';
+export type { ToolExecutor, ToolExecutorExecuteOptions, ToolExecutorOptions } from './tool-executor';

package/dist/dim-agent-sdk/src/agent-core/{LoopRunner.d.ts → loop-runner.d.ts}

@@ -1,12 +1,12 @@
 import type { AssistantMessage, MessageContentInput, SessionStreamEvent } from '../contracts';
 import type { ContextManager } from '../context';
-import type { PluginHost } from '../plugin-host/PluginHost';
-import type { MessageFactory } from './MessageFactory';
-import type { ModelTurnCollector } from './ModelTurnCollector';
+import type { PluginHost } from '../plugin-host/plugin-host';
+import type { MessageFactory } from './message-factory';
+import type { ModelTurnCollector } from './model-turn-collector';
 import type { NotificationBus } from './notifications';
 import type { RuntimeSessionState } from './session-state';
-import type { TerminationPolicy } from './TerminationPolicy';
-import type { ToolExecutor } from './ToolExecutor';
+import type { TerminationPolicy } from './termination-policy';
+import type { ToolExecutor } from './tool-executor';
 export interface LoopRunnerDependencies {
     messageFactory: MessageFactory;
     turnCollector: ModelTurnCollector;
@@ -19,6 +19,7 @@ export interface LoopRunnerDependencies {
 export interface LoopRunnerRunOptions {
     signal?: AbortSignal;
     onDone?: (message: AssistantMessage) => Promise<void> | void;
+    persistentPromptSegments?: string[];
 }
 export declare class LoopRunner {
     private readonly messageFactory;

package/dist/dim-agent-sdk/src/agent-core/notifications.d.ts

@@ -1,6 +1,6 @@
 import type { SessionStatus } from '../contracts';
 import type { NotificationPayload } from '@archships/dim-plugin-api';
-import type { PluginHost } from '../plugin-host/PluginHost';
+import type { PluginHost } from '../plugin-host/plugin-host';
 import type { AgentServices } from '../services';
 export interface NotificationContext {
     sessionId?: string;

package/dist/dim-agent-sdk/src/agent-core/session-state.d.ts

@@ -1,5 +1,5 @@
-import type { CompactionOptions, CompactionState, Message, ModelClient, ModelRef, PluginSessionStateEntry, Usage } from '../contracts';
-import type { ToolRegistry } from '../tools/ToolRegistry';
+import type { CompactionOptions, CompactionState, Message, MessageQueueSnapshot, ModelClient, ModelRef, PluginSessionStateEntry, Usage } from '../contracts';
+import type { ToolRegistry } from '../tools/tool-registry';
 export interface RuntimeSessionState {
     id: string;
     model: ModelClient;
@@ -13,6 +13,7 @@ export interface RuntimeSessionState {
     usage: Usage;
     compaction: CompactionState;
     pluginState: Record<string, PluginSessionStateEntry>;
+    messageQueue: MessageQueueSnapshot;
     compactionOptions?: CompactionOptions;
     createdAt: number;
     updatedAt: number;

package/dist/dim-agent-sdk/src/agent-core/{Session.d.ts → session.d.ts}

@@ -1,9 +1,9 @@
-import type { AssistantMessage, CompactionOptions, CompactionState, CompactionUpdate, Message, MessageContentInput, ModelClient, ModelRef, PluginSessionStateEntry, SessionStatus, SessionSnapshot, SessionStreamEvent, Usage } from '../contracts';
+import type { CompactionOptions, CompactionState, CompactionUpdate, Message, MessageContentInput, MessageQueueConfig, MessageQueueSnapshot, MessageQueueStatus, PendingMessageKind, ModelClient, ModelRef, PluginSessionStateEntry, SessionStatus, SessionSnapshot, SessionStreamEvent, Usage } from '../contracts';
 import type { ContextManager } from '../context';
 import type { StateStore } from '../persistence/store';
-import type { PluginHost } from '../plugin-host/PluginHost';
+import type { PluginHost } from '../plugin-host/plugin-host';
 import type { AgentServices } from '../services';
-import type { ToolRegistry } from '../tools/ToolRegistry';
+import type { ToolRegistry } from '../tools/tool-registry';
 import type { ApprovalManager } from './approvals';
 import { DefaultCompactionService } from './compaction';
 import { DefaultPluginStateService } from './plugin-state';
@@ -22,6 +22,8 @@ export interface SessionOptions {
     usage?: Usage;
     compaction?: CompactionState;
     pluginState?: Record<string, PluginSessionStateEntry>;
+    messageQueue?: MessageQueueSnapshot;
+    messageQueueConfig?: Partial<MessageQueueConfig>;
     compactionOptions?: CompactionOptions;
     createdAt?: number;
     updatedAt?: number;
@@ -33,6 +35,15 @@ export interface SessionOptions {
     compactionService: DefaultCompactionService;
     pluginStateService: DefaultPluginStateService;
 }
+interface SessionQueueSendOptions {
+    priority?: number;
+}
+interface SessionReceiveOptions {
+    signal?: AbortSignal;
+}
+interface ClearQueueFilter {
+    kind?: PendingMessageKind;
+}
 export declare class Session {
     readonly id: string;
     readonly createdAt: number;
@@ -46,7 +57,14 @@ export declare class Session {
     private readonly compactionService;
     private readonly pluginStateService;
     private readonly pluginControllers;
+    private readonly bufferedEvents;
+    private readonly stateChangeWaiters;
     private activeRunCount;
+    private processingPromise;
+    private receiveActive;
+    private activeReceiveSignal?;
+    private haltProcessingUntilReceive;
+    private saveChain;
     constructor(options: SessionOptions);
     get messages(): Message[];
     get usage(): Usage;
@@ -58,16 +76,37 @@ export declare class Session {
     get updatedAt(): number;
     getCwd(): string | undefined;
     setCwd(cwd: string): void;
+    send(input: MessageContentInput, options?: SessionQueueSendOptions): string;
+    sendBatch(items: Array<{
+        input: MessageContentInput;
+        options?: SessionQueueSendOptions;
+    }>): string[];
+    steer(input: MessageContentInput, options?: SessionQueueSendOptions): string;
+    cancelQueuedItem(itemId: string): boolean;
+    getQueueStatus(): MessageQueueStatus;
+    clearQueue(filter?: ClearQueueFilter): number;
+    receive(options?: SessionReceiveOptions): AsyncGenerator<SessionStreamEvent, void, void>;
     compact(update: CompactionUpdate): Promise<void>;
     save(): Promise<void>;
+    private writeSnapshot;
     toSnapshot(): SessionSnapshot;
-    send(input: MessageContentInput, options?: {
-        signal?: AbortSignal;
-    }): Promise<AssistantMessage>;
-    stream(input: MessageContentInput, options?: {
-        signal?: AbortSignal;
-    }): AsyncGenerator<SessionStreamEvent, AssistantMessage, void>;
+    private enqueueItem;
+    private onQueueMutated;
+    private hasRunnableItems;
+    private ensureQueueProcessing;
+    private processQueue;
+    private dequeueNextRunnableItem;
+    private processQueuedItem;
+    private attachQueueContext;
+    private createErrorEvent;
+    private pushBufferedEvent;
+    private scheduleSave;
+    private persistStateQuietly;
+    private enqueueSave;
+    private waitForStateChange;
+    private notifyStateChange;
     private createLoopRunner;
     private readEstimatedInputTokens;
     private createHookContext;
 }
+export {};

package/dist/dim-agent-sdk/src/agent-core/{ToolExecutor.d.ts → tool-executor.d.ts}

@@ -1,7 +1,7 @@
 import type { CallToolResult, SessionPluginEvent, SessionStatus, ToolCall } from '../contracts';
-import type { PluginHost } from '../plugin-host/PluginHost';
+import type { PluginHost } from '../plugin-host/plugin-host';
 import type { AgentServices } from '../services';
-import type { ToolRegistry } from '../tools/ToolRegistry';
+import type { ToolRegistry } from '../tools/tool-registry';
 import type { ApprovalManager } from './approvals';
 import type { NotificationBus } from './notifications';
 export interface ToolExecutorExecuteOptions {

package/dist/dim-agent-sdk/src/context/{AutoContextManager.d.ts → auto-context-manager.d.ts}

@@ -1,4 +1,4 @@
-import type { PluginHost } from '../plugin-host/PluginHost';
+import type { PluginHost } from '../plugin-host/plugin-host';
 import type { AgentServices } from '../services';
 import type { ContextItem, ContextManager, ContextResolveOptions } from './types';
 export interface AutoContextManagerOptions {

package/dist/dim-agent-sdk/src/context/index.d.ts

@@ -1,4 +1,4 @@
-export { AutoContextManager } from './AutoContextManager';
-export type { AutoContextManagerOptions } from './AutoContextManager';
+export { AutoContextManager } from './auto-context-manager';
+export type { AutoContextManagerOptions } from './auto-context-manager';
 export type { CompactionBudgetInfo, CompactionCheckpoint, CompactionEstimator, CompactionEstimatorInput, CompactionOptions, CompactionService, CompactionState, CompactionTriggerReason, CompactionUpdate, } from './compaction';
 export type { ContextItem, ContextManager, ContextResolveOptions } from './types';

package/dist/dim-agent-sdk/src/contracts/event.d.ts

@@ -1,6 +1,12 @@
 import type { SessionErrorPayload, Usage } from './common';
 import type { AssistantMessage } from './message';
+import type { PendingMessageKind } from './state';
 import type { CallToolResult, ToolCall } from './tool';
+export interface SessionQueueEventContext {
+    itemId?: string;
+    itemKind?: PendingMessageKind;
+    priority?: number;
+}
 export interface SessionPluginEvent {
     type: 'plugin_event';
     sessionId: string;
@@ -8,30 +14,30 @@ export interface SessionPluginEvent {
     event: string;
     data?: Record<string, unknown>;
 }
-export type SessionStreamEvent = {
+export type SessionStreamEvent = ({
     type: 'text_delta';
     sessionId: string;
     delta: string;
-} | {
+} & SessionQueueEventContext) | ({
     type: 'thinking_delta';
     sessionId: string;
     delta: string;
-} | {
+} & SessionQueueEventContext) | ({
     type: 'tool_call';
     sessionId: string;
     toolCall: ToolCall;
-} | {
+} & SessionQueueEventContext) | ({
     type: 'tool_result';
     sessionId: string;
     toolCallId: string;
     result: CallToolResult;
-} | SessionPluginEvent | {
+} & SessionQueueEventContext) | (SessionPluginEvent & SessionQueueEventContext) | ({
     type: 'done';
     sessionId: string;
     message: AssistantMessage;
     usage?: Usage;
-} | {
+} & SessionQueueEventContext) | ({
     type: 'error';
     sessionId: string;
     error: SessionErrorPayload;
-};
+} & SessionQueueEventContext);

package/dist/dim-agent-sdk/src/contracts/state.d.ts

@@ -1,10 +1,40 @@
 import type { CompactionState } from './compaction';
+import type { MessageContentInput } from './content';
 import type { PluginSessionStateEntry } from './plugin-state';
 import type { Usage } from './common';
 import type { Message } from './message';
 import type { ModelRef } from './model';
+export interface MessageQueueConfig {
+    autoProcessQueue: boolean;
+    maxQueueSize?: number;
+}
+export type PendingMessageKind = 'user' | 'steer';
+export interface PendingMessage {
+    id: string;
+    input: MessageContentInput;
+    kind: PendingMessageKind;
+    priority: number;
+    enqueuedAt: number;
+}
+export interface MessageQueueSnapshot {
+    items: PendingMessage[];
+    config: MessageQueueConfig;
+}
+export interface MessageQueueStatusItem {
+    id: string;
+    kind: PendingMessageKind;
+    priority: number;
+    enqueuedAt: number;
+    preview: string;
+}
+export interface MessageQueueStatus {
+    length: number;
+    items: MessageQueueStatusItem[];
+    isProcessing: boolean;
+    config: MessageQueueConfig;
+}
 export interface SessionSnapshot {
-    schemaVersion: 1;
+    schemaVersion: 1 | 2;
     sessionId: string;
     model?: ModelRef;
     cwd?: string;
@@ -15,6 +45,7 @@ export interface SessionSnapshot {
     createdAt: number;
     updatedAt: number;
     metadata?: Record<string, unknown>;
+    messageQueue?: MessageQueueSnapshot;
 }
 export interface SessionStatus {
     sessionId: string;

package/dist/dim-agent-sdk/src/index.d.ts

@@ -1,16 +1,17 @@
-export type { CallToolResult, CompactionBudgetInfo, CompactionCheckpoint, CompactionEstimator, CompactionEstimatorInput, CompactionOptions, CompactionService, CompactionState, CompactionTriggerReason, CompactionUpdate, ContentBlock, Message, MessageContentInput, ModelAdapter, ModelClient, ModelRequest, ModelStreamEvent, ModelStopReason, ModelRef, PluginSessionStateEntry, PluginStateService, SessionStatus, SessionPluginEvent, SessionSnapshot, SessionStreamEvent, Tool, ToolCall, ToolDefinition, ToolExecutionContext, ToolExecutionPluginEvent, ToolInputSchema, Usage, } from './contracts';
+export type { CallToolResult, CompactionBudgetInfo, CompactionCheckpoint, CompactionEstimator, CompactionEstimatorInput, CompactionOptions, CompactionService, CompactionState, CompactionTriggerReason, CompactionUpdate, ContentBlock, Message, MessageContentInput, MessageQueueConfig, MessageQueueSnapshot, MessageQueueStatus, ModelAdapter, ModelClient, ModelRequest, ModelStreamEvent, ModelStopReason, ModelRef, PluginSessionStateEntry, PendingMessage, PendingMessageKind, PluginStateService, SessionStatus, SessionPluginEvent, SessionSnapshot, SessionStreamEvent, Tool, ToolCall, ToolDefinition, ToolExecutionContext, ToolExecutionPluginEvent, ToolInputSchema, Usage, } from './contracts';
 export { normalizeContent } from './contracts/content-normalize';
-export { Agent, createAgent } from './agent-core/Agent';
-export type { CreateAgentOptions } from './agent-core/Agent';
+export { Agent, createAgent } from './agent-core/agent';
+export type { CreateAgentOptions } from './agent-core/agent';
 export { DefaultCompactionService } from './agent-core/compaction';
-export { Session } from './agent-core/Session';
+export { Session } from './agent-core/session';
 export { SessionExecutionError } from './agent-core/errors';
 export { FileStateStore, InMemoryStateStore } from './persistence';
 export { BaseTool, EditTool, ExecTool, ReadTool, ToolRegistry, WriteTool, } from './tools';
 export { appendToolCallArgsDelta, finalizeToolCall, startToolCall, } from './agent-core/tool-call';
 export { normalizeToolResult, normalizeToolSchema } from './contracts/tool-normalize';
-export { createAnthropicAdapter, createGeminiAdapter, createOpenAIAdapter, createOpenAIResponsesAdapter } from './providers';
-export { createModel } from './agent-core/createModel';
+export { createAihubmixAdapter, createAihubmixResponsesAdapter, createAnthropicAdapter, createDeepSeekAdapter, createGeminiAdapter, createMoonshotAIAdapter, createOpenAIAdapter, createOpenAIResponsesAdapter, createXaiAdapter, createXaiResponsesAdapter, createZenMuxAdapter, } from './providers';
+export type { AihubmixAdapterOptions, AihubmixResponsesAdapterOptions, AnthropicAdapterOptions, DeepSeekAdapterOptions, GeminiAdapterOptions, MoonshotAIAdapterOptions, OpenAIAdapterOptions, OpenAIResponsesAdapterOptions, XaiAdapterOptions, XaiResponsesAdapterOptions, ZenMuxAdapterOptions, } from './providers';
+export { createModel } from './agent-core/create-model';
 export type { ContextItem, ContextManager, ContextResolveOptions, } from './context';
 export { AutoContextManager } from './context';
 export type { AgentServices, ExecGateway, ExecOptions, ExecResult, FileSystemGateway, FileSystemPermission, GitGateway, GlobOptions, GrepMatch, GrepOptions, ModelGateway, NetworkGateway, PermissionSpec, } from './services';

package/dist/dim-agent-sdk/src/persistence/index.d.ts

@@ -1,6 +1,6 @@
-export { FileStateStore } from './FileStateStore';
-export type { FileStateStoreOptions } from './FileStateStore';
-export { InMemoryStateStore } from './InMemoryStateStore';
-export { JsonSnapshotCodec, sessionSnapshotCodec } from './SnapshotCodec';
-export type { SnapshotCodec, SnapshotCodecInput } from './SnapshotCodec';
+export { FileStateStore } from './file-state-store';
+export type { FileStateStoreOptions } from './file-state-store';
+export { InMemoryStateStore } from './in-memory-state-store';
+export { JsonSnapshotCodec, sessionSnapshotCodec } from './snapshot-codec';
+export type { SnapshotCodec, SnapshotCodecInput } from './snapshot-codec';
 export type { StateStore } from './store';

package/dist/dim-agent-sdk/src/persistence/{SnapshotCodec.d.ts → snapshot-codec.d.ts}

@@ -1,4 +1,4 @@
-import type { CompactionState, Message, ModelRef, PluginSessionStateEntry, SessionSnapshot, Usage } from '../contracts';
+import type { CompactionState, Message, MessageQueueSnapshot, ModelRef, PluginSessionStateEntry, SessionSnapshot, Usage } from '../contracts';
 export interface SnapshotCodecInput {
     sessionId: string;
     model?: ModelRef;
@@ -10,6 +10,7 @@ export interface SnapshotCodecInput {
     createdAt: number;
     updatedAt: number;
     metadata?: Record<string, unknown>;
+    messageQueue?: MessageQueueSnapshot;
 }
 export interface SnapshotCodec {
     encode(input: SnapshotCodecInput): SessionSnapshot;

package/dist/dim-agent-sdk/src/plugin-host/index.d.ts

@@ -1,4 +1,4 @@
 export { allowToolCall, askToolCall, continueHook, continueNotification, continueRun, denyToolCall, finalizeRun, provideToolResult, replaceHook, replaceNotification, replaceToolCall, stopHook, suppressNotification, } from './helpers';
-export { HookPipeline } from './HookPipeline';
-export { PluginHost } from './PluginHost';
+export { HookPipeline } from './hook-pipeline';
+export { PluginHost } from './plugin-host';
 export type { AgentMode, AnyHookRegistrationEntry, ApprovalDecision, ApprovalRequest, AskApprovalInput, ContextCompactBeforePayload, ContextContributor, ContextContributorInput, ContextItem, DimPlugin, HookControlResult, HookDescriptor, HookHandler, HookMatcher, HookMiddleware, HookMiddlewareResult, HookMode, HookName, HookObserver, HookPayloadMap, HookRegistration, HookRegistrationEntry, InternalHookName, NotificationControlResult, NotificationHookPayload, NotificationPayload, PermissionSpec, PluginContext, PluginManifest, PluginRuntimeContext, PluginSessionControllerContext, PluginSessionControllerFactory, PluginSessionStateEntry, PluginStateService, PluginServices, PluginSetupResult, PromptContributor, PromptContributorInput, PublicHookName, RunEndPayload, RunLoopDecision, RunStartPayload, RunStopControlResult, RunStopPayload, SessionStatus, SessionErrorHookPayload, SubagentStopPayload, ToolBeforeExecuteControlResult, } from './types';

package/dist/dim-agent-sdk/src/plugin-host/{PluginHost.d.ts → plugin-host.d.ts}

@@ -3,7 +3,7 @@ import type { SessionStatus } from '../contracts';
 import { PermissionGateway } from '../services';
 import type { ActivityTracker, AgentServices } from '../services';
 import type { Tool } from '../contracts';
-import { HookPipeline } from './HookPipeline';
+import { HookPipeline } from './hook-pipeline';
 import type { ContextContributorInput, DimPlugin, HookName, HookPayloadMap, PluginRuntimeContext, PromptContributorInput, RunStopPayload, ToolBeforeExecutePayload } from './types';
 type SpecialHookName = 'notify.message' | 'run.stop' | 'tool.beforeExecute';
 type StandardHookName = Exclude<HookName, SpecialHookName>;
@@ -41,13 +41,13 @@ export declare class PluginHost {
     }): Promise<HookPayloadMap[N]>;
     runToolBeforeExecute(payload: ToolBeforeExecutePayload, context?: Omit<PluginRuntimeContext, 'agentId' | 'services'> & {
         services?: AgentServices;
-    }): Promise<import("./HookPipeline").ToolBeforeExecuteHookResult>;
+    }): Promise<import("./hook-pipeline").ToolBeforeExecuteHookResult>;
     runNotifyMessage(payload: HookPayloadMap['notify.message'], context?: Omit<PluginRuntimeContext, 'agentId' | 'services'> & {
         services?: AgentServices;
-    }): Promise<import("./HookPipeline").NotifyMessageHookResult>;
+    }): Promise<import("./hook-pipeline").NotifyMessageHookResult>;
     runRunStop(payload: RunStopPayload, context?: Omit<PluginRuntimeContext, 'agentId' | 'services'> & {
         services?: AgentServices;
-    }): Promise<import("./HookPipeline").RunStopHookResult>;
+    }): Promise<import("./hook-pipeline").RunStopHookResult>;
     runObservers<N extends HookName>(name: N, payload: HookPayloadMap[N], context?: Omit<PluginRuntimeContext, 'agentId' | 'services'> & {
         services?: AgentServices;
     }): Promise<void>;

package/dist/dim-agent-sdk/src/providers/aihubmix/adapter.d.ts

@@ -0,0 +1,17 @@
+import type { ConfiguredModelAdapter } from '../../contracts';
+import { type ProviderFactoryOptionsBase } from '../core/create-provider-factory';
+type FetchLike = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+export interface AihubmixAdapterOptions extends ProviderFactoryOptionsBase {
+    /**
+     * AIHubMix API key. When omitted, your custom fetch must attach the real
+     * upstream credentials before the request is sent.
+     */
+    apiKey?: string;
+    fetch?: FetchLike;
+    /**
+     * Compatibility mode forwarded to the AIHubMix provider package.
+     */
+    compatibility?: 'strict' | 'compatible';
+}
+export declare const createAihubmixAdapter: (options: AihubmixAdapterOptions) => ConfiguredModelAdapter;
+export {};

package/dist/dim-agent-sdk/src/providers/aihubmix/driver.d.ts

@@ -0,0 +1,3 @@
+import type { ProviderDriver } from '../core/create-provider-factory';
+import type { AihubmixAdapterOptions } from './adapter';
+export declare const aihubmixDriver: ProviderDriver<AihubmixAdapterOptions>;

package/dist/dim-agent-sdk/src/providers/aihubmix/index.d.ts

@@ -0,0 +1,2 @@
+export { createAihubmixAdapter } from './adapter';
+export type { AihubmixAdapterOptions } from './adapter';

package/dist/dim-agent-sdk/src/providers/aihubmix-responses/adapter.d.ts

@@ -0,0 +1,17 @@
+import type { ConfiguredModelAdapter } from '../../contracts';
+import { type ProviderFactoryOptionsBase } from '../core/create-provider-factory';
+type FetchLike = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+export interface AihubmixResponsesAdapterOptions extends ProviderFactoryOptionsBase {
+    /**
+     * AIHubMix API key. When omitted, your custom fetch must attach the real
+     * upstream credentials before the request is sent.
+     */
+    apiKey?: string;
+    fetch?: FetchLike;
+    /**
+     * Compatibility mode forwarded to the AIHubMix provider package.
+     */
+    compatibility?: 'strict' | 'compatible';
+}
+export declare const createAihubmixResponsesAdapter: (options: AihubmixResponsesAdapterOptions) => ConfiguredModelAdapter;
+export {};

package/dist/dim-agent-sdk/src/providers/aihubmix-responses/driver.d.ts

@@ -0,0 +1,12 @@
+import type { ProviderDriver } from '../core/create-provider-factory';
+import type { AihubmixResponsesAdapterOptions } from './adapter';
+export declare const aihubmixResponsesDriver: ProviderDriver<AihubmixResponsesAdapterOptions>;
+export declare function createReasoningAwareResponsesFetch(input: {
+    fetch?: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+    stripAuthorization: boolean;
+    requestReasoning: {
+        effort?: string;
+        summary?: string;
+    } | undefined;
+}): typeof fetch;
+export declare function parseJsonBody(body: BodyInit): unknown;

package/dist/dim-agent-sdk/src/providers/aihubmix-responses/index.d.ts

@@ -0,0 +1,2 @@
+export { createAihubmixResponsesAdapter } from './adapter';
+export type { AihubmixResponsesAdapterOptions } from './adapter';

package/dist/dim-agent-sdk/src/providers/aihubmix-responses/state.d.ts

@@ -0,0 +1,7 @@
+import type { LanguageModelV3GenerateResult } from '@ai-sdk/provider';
+import type { Message } from '../../contracts';
+export declare function sliceMessagesForAihubmixResponses(messages: Message[]): {
+    messages: Message[];
+    previousResponseId?: string;
+};
+export declare function createAihubmixResponsesAssistantMetadata(result: LanguageModelV3GenerateResult): Record<string, unknown> | undefined;

package/dist/dim-agent-sdk/src/providers/anthropic/adapter.d.ts

@@ -1,13 +1,24 @@
 import type { ConfiguredModelAdapter } from '../../contracts';
+import { type ProviderFactoryOptionsBase } from '../core/create-provider-factory';
 type FetchLike = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
-export interface AnthropicAdapterOptions {
+export interface AnthropicAdapterOptions extends ProviderFactoryOptionsBase {
+    /**
+     * Anthropic API key. When omitted, you must inject real upstream auth through
+     * custom fetch or explicit auth headers.
+     */
     apiKey?: string;
+    /**
+     * Custom Anthropic base URL prefix.
+     * When the value does not end with `/v1`, the adapter appends `/v1`
+     * before handing it to the Anthropic AI SDK.
+     */
     baseUrl?: string;
-    defaultModel: string;
-    provider?: string;
     fetch?: FetchLike;
+    /**
+     * Custom headers sent to the Anthropic AI SDK request layer.
+     */
     headers?: Record<string, string>;
     anthropicVersion?: string;
 }
-export declare function createAnthropicAdapter(options: AnthropicAdapterOptions): ConfiguredModelAdapter;
+export declare const createAnthropicAdapter: (options: AnthropicAdapterOptions) => ConfiguredModelAdapter;
 export {};

package/dist/dim-agent-sdk/src/providers/anthropic/driver.d.ts

@@ -0,0 +1,3 @@
+import type { ProviderDriver } from '../core/create-provider-factory';
+import type { AnthropicAdapterOptions } from './adapter';
+export declare const anthropicDriver: ProviderDriver<AnthropicAdapterOptions>;

package/dist/dim-agent-sdk/src/providers/anthropic/index.d.ts

@@ -0,0 +1,2 @@
+export { createAnthropicAdapter } from './adapter';
+export type { AnthropicAdapterOptions } from './adapter';

package/dist/dim-agent-sdk/src/providers/anthropic/state.d.ts

@@ -0,0 +1,6 @@
+import type { LanguageModelV3GenerateResult } from '@ai-sdk/provider';
+import type { AssistantMessage } from '../../contracts';
+import type { AssistantPromptPart } from '../shared/prompt';
+export declare function anthropicAssistantPrefixParts(message: AssistantMessage): AssistantPromptPart[];
+export declare function hasAnthropicThinkingState(message: AssistantMessage): boolean;
+export declare function createAnthropicAssistantMetadata(result: LanguageModelV3GenerateResult): Record<string, unknown> | undefined;