@archships/dim-agent-sdk 0.0.3 → 0.0.5

package/dist/dim-agent-sdk/src/providers/core/create-provider-factory.d.ts

@@ -0,0 +1,39 @@
+import type { ConfiguredModelAdapter, ModelErrorPayload, ModelRef, ModelRequest, ModelStopReason, Usage } from '../../contracts';
+export interface ProviderFactoryOptionsBase {
+    defaultModel: string;
+    provider?: string;
+}
+export type ProviderDriverContentSegment = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'thinking';
+    text: string;
+} | {
+    type: 'tool_call';
+    callId: string;
+    toolName: string;
+    argsText: string;
+};
+export interface ProviderDriverResult {
+    content: ProviderDriverContentSegment[];
+    stopReason: ModelStopReason;
+    usage?: Usage;
+    assistantMetadata?: Record<string, unknown>;
+}
+export interface ProviderDriverContext<Options extends ProviderFactoryOptionsBase = ProviderFactoryOptionsBase> {
+    options: Readonly<Options>;
+    provider: string;
+    defaultModel: ModelRef;
+    request: ModelRequest;
+}
+export interface ProviderDriver<Options extends ProviderFactoryOptionsBase = ProviderFactoryOptionsBase> {
+    generate(context: ProviderDriverContext<Options>): Promise<ProviderDriverResult>;
+    normalizeError?(error: unknown, context: ProviderDriverContext<Options>): Promise<ModelErrorPayload> | ModelErrorPayload;
+}
+interface ProviderFactoryDefinition<Options extends ProviderFactoryOptionsBase> {
+    defaultProvider: string;
+    driver: ProviderDriver<Options>;
+}
+export declare function createProviderFactory<Options extends ProviderFactoryOptionsBase>(definition: ProviderFactoryDefinition<Options>): (options: Options) => ConfiguredModelAdapter;
+export {};

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

@@ -0,0 +1,2 @@
+export { createProviderFactory } from './create-provider-factory';
+export type { ProviderDriver, ProviderFactoryOptionsBase } from './create-provider-factory';

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

@@ -0,0 +1,11 @@
+import type { ConfiguredModelAdapter } from '../../contracts';
+import { type ProviderFactoryOptionsBase } from '../core/create-provider-factory';
+type FetchLike = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+export interface DeepSeekAdapterOptions extends ProviderFactoryOptionsBase {
+    apiKey?: string;
+    baseUrl?: string;
+    fetch?: FetchLike;
+    headers?: Record<string, string>;
+}
+export declare const createDeepSeekAdapter: (options: DeepSeekAdapterOptions) => ConfiguredModelAdapter;
+export {};

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

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

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

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

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

@@ -1,12 +1,11 @@
 import type { ConfiguredModelAdapter } from '../../contracts';
+import { type ProviderFactoryOptionsBase } from '../core/create-provider-factory';
 type FetchLike = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
-export interface GeminiAdapterOptions {
+export interface GeminiAdapterOptions extends ProviderFactoryOptionsBase {
     apiKey?: string;
     baseUrl?: string;
-    defaultModel: string;
-    provider?: string;
     fetch?: FetchLike;
     headers?: Record<string, string>;
 }
-export declare function createGeminiAdapter(options: GeminiAdapterOptions): ConfiguredModelAdapter;
+export declare const createGeminiAdapter: (options: GeminiAdapterOptions) => ConfiguredModelAdapter;
 export {};

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

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

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

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

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

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

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

@@ -1,8 +1,22 @@
-export { createAnthropicAdapter } from './anthropic/adapter';
-export type { AnthropicAdapterOptions } from './anthropic/adapter';
-export { createGeminiAdapter } from './gemini/adapter';
-export type { GeminiAdapterOptions } from './gemini/adapter';
-export { createOpenAIAdapter } from './openai/adapter';
-export type { OpenAIAdapterOptions } from './openai/adapter';
-export { createOpenAIResponsesAdapter } from './openai-responses/adapter';
-export type { OpenAIResponsesAdapterOptions } from './openai-responses/adapter';
+export { createAihubmixAdapter } from './aihubmix';
+export type { AihubmixAdapterOptions } from './aihubmix';
+export { createAihubmixResponsesAdapter } from './aihubmix-responses';
+export type { AihubmixResponsesAdapterOptions } from './aihubmix-responses';
+export { createAnthropicAdapter } from './anthropic';
+export type { AnthropicAdapterOptions } from './anthropic';
+export { createDeepSeekAdapter } from './deepseek';
+export type { DeepSeekAdapterOptions } from './deepseek';
+export { createGeminiAdapter } from './gemini';
+export type { GeminiAdapterOptions } from './gemini';
+export { createMoonshotAIAdapter } from './moonshotai';
+export type { MoonshotAIAdapterOptions } from './moonshotai';
+export { createOpenAIAdapter } from './openai';
+export type { OpenAIAdapterOptions } from './openai';
+export { createOpenAIResponsesAdapter } from './openai-responses';
+export type { OpenAIResponsesAdapterOptions } from './openai-responses';
+export { createXaiAdapter } from './xai';
+export type { XaiAdapterOptions } from './xai';
+export { createXaiResponsesAdapter } from './xai-responses';
+export type { XaiResponsesAdapterOptions } from './xai-responses';
+export { createZenMuxAdapter } from './zenmux';
+export type { ZenMuxAdapterOptions } from './zenmux';

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

@@ -0,0 +1,11 @@
+import type { ConfiguredModelAdapter } from '../../contracts';
+import { type ProviderFactoryOptionsBase } from '../core/create-provider-factory';
+type FetchLike = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+export interface MoonshotAIAdapterOptions extends ProviderFactoryOptionsBase {
+    apiKey?: string;
+    baseUrl?: string;
+    fetch?: FetchLike;
+    headers?: Record<string, string>;
+}
+export declare const createMoonshotAIAdapter: (options: MoonshotAIAdapterOptions) => ConfiguredModelAdapter;
+export {};

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

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

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

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

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

@@ -1,12 +1,11 @@
 import type { ConfiguredModelAdapter } from '../../contracts';
+import { type ProviderFactoryOptionsBase } from '../core/create-provider-factory';
 type FetchLike = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
-export interface OpenAIAdapterOptions {
+export interface OpenAIAdapterOptions extends ProviderFactoryOptionsBase {
     apiKey?: string;
     baseUrl?: string;
-    defaultModel: string;
-    provider?: string;
     fetch?: FetchLike;
     headers?: Record<string, string>;
 }
-export declare function createOpenAIAdapter(options: OpenAIAdapterOptions): ConfiguredModelAdapter;
+export declare const createOpenAIAdapter: (options: OpenAIAdapterOptions) => ConfiguredModelAdapter;
 export {};

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

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

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

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

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

@@ -1,12 +1,11 @@
 import type { ConfiguredModelAdapter } from '../../contracts';
+import { type ProviderFactoryOptionsBase } from '../core/create-provider-factory';
 type FetchLike = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
-export interface OpenAIResponsesAdapterOptions {
+export interface OpenAIResponsesAdapterOptions extends ProviderFactoryOptionsBase {
     apiKey?: string;
     baseUrl?: string;
-    defaultModel: string;
-    provider?: string;
     fetch?: FetchLike;
     headers?: Record<string, string>;
 }
-export declare function createOpenAIResponsesAdapter(options: OpenAIResponsesAdapterOptions): ConfiguredModelAdapter;
+export declare const createOpenAIResponsesAdapter: (options: OpenAIResponsesAdapterOptions) => ConfiguredModelAdapter;
 export {};

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

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

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

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

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

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

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

@@ -0,0 +1,7 @@
+import type { LanguageModelV3, LanguageModelV3CallOptions, LanguageModelV3GenerateResult } from '@ai-sdk/provider';
+import type { ProviderDriverResult } from '../core/create-provider-factory';
+export declare function generateWithAiSdk(input: {
+    model: LanguageModelV3;
+    callOptions: LanguageModelV3CallOptions;
+    createAssistantMetadata?(result: LanguageModelV3GenerateResult): Record<string, unknown> | undefined;
+}): Promise<ProviderDriverResult>;

package/dist/dim-agent-sdk/src/providers/shared/auth-warning.d.ts

@@ -0,0 +1,6 @@
+export declare function warnIfPlaceholderApiKey(input: {
+    provider: string;
+    shouldWarn: boolean;
+    hint?: string;
+}): void;
+export declare function resetPlaceholderApiKeyWarningsForTest(): void;

package/dist/dim-agent-sdk/src/providers/shared/fetch.d.ts

@@ -0,0 +1,8 @@
+type FetchLike = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+export declare function createProviderFetch(input: {
+    fetch?: FetchLike;
+    stripHeaders?: string[];
+    stripWhen?: boolean;
+}): typeof fetch;
+export declare function hasHeader(headers: Record<string, string> | undefined, target: string): boolean;
+export {};

package/dist/dim-agent-sdk/src/providers/shared/http-error.d.ts

@@ -1,3 +1,4 @@
+import { APICallError } from '@ai-sdk/provider';
 import type { ModelErrorPayload } from '../../contracts';
 export declare function createHttpErrorPayload(input: {
     code: string;
@@ -5,3 +6,12 @@ export declare function createHttpErrorPayload(input: {
     endpoint: string;
     response: Response;
 }): Promise<ModelErrorPayload>;
+export declare function createApiCallErrorPayload(input: {
+    code: string;
+    provider: string;
+    error: APICallError;
+}): ModelErrorPayload;
+export declare function createRequestErrorPayload(input: {
+    code: string;
+    error: unknown;
+}): ModelErrorPayload;

package/dist/dim-agent-sdk/src/providers/shared/prompt.d.ts

@@ -0,0 +1,14 @@
+import type { LanguageModelV3FilePart, LanguageModelV3FunctionTool, LanguageModelV3Message, LanguageModelV3Prompt, LanguageModelV3TextPart, LanguageModelV3ToolCallPart } from '@ai-sdk/provider';
+import type { AssistantMessage, ContentBlock, Message, ToolDefinition, ToolMessage } from '../../contracts';
+export type AssistantPromptPart = Extract<LanguageModelV3Message, {
+    role: 'assistant';
+}>['content'][number];
+export declare function mapToolDefinitionsToLanguageModelTools(tools: ToolDefinition[] | undefined): LanguageModelV3FunctionTool[] | undefined;
+export declare function messagesToLanguageModelPrompt(messages: Message[], options?: {
+    assistantPrefixParts?(message: AssistantMessage): AssistantPromptPart[];
+}): LanguageModelV3Prompt;
+export declare function contentBlocksToPromptParts(content: ContentBlock[]): Array<LanguageModelV3TextPart | LanguageModelV3FilePart>;
+export declare function toolCallsToPromptParts(toolCalls: AssistantMessage['toolCalls']): LanguageModelV3ToolCallPart[];
+export declare function toolMessageToPrompt(message: ToolMessage): Extract<LanguageModelV3Message, {
+    role: 'tool';
+}>;

package/dist/dim-agent-sdk/src/providers/shared/reasoning.d.ts

@@ -1,14 +1,37 @@
 export declare function normalizeReasoningConfig(reasoning: Record<string, unknown> | undefined): Record<string, unknown> | undefined;
 export declare function resolveReasoningBudget(reasoning: Record<string, unknown> | undefined, fallback?: number): number | undefined;
-export declare function buildOpenAIResponsesReasoning(reasoning: Record<string, unknown> | undefined): Record<string, unknown> | undefined;
-export declare function buildAnthropicThinking(reasoning: Record<string, unknown> | undefined): {
-    maxTokens?: number;
+export declare function resolveReasoningEffort(reasoning: Record<string, unknown> | undefined, allowedValues?: readonly string[]): string | undefined;
+export declare function resolveLowHighReasoningEffort(reasoning: Record<string, unknown> | undefined): 'low' | 'high' | undefined;
+export declare function resolveLowMediumHighReasoningEffort(reasoning: Record<string, unknown> | undefined): 'low' | 'medium' | 'high' | undefined;
+export declare function buildOpenAIResponsesProviderOptions(reasoning: Record<string, unknown> | undefined): Record<string, unknown> | undefined;
+export declare function buildOpenAIResponsesRequestReasoning(reasoning: Record<string, unknown> | undefined): {
+    effort?: string;
+    summary?: string;
+} | undefined;
+export declare function buildReasoningEffortProviderOptions(reasoning: Record<string, unknown> | undefined, allowedValues?: readonly string[]): {
+    reasoningEffort: string;
+} | undefined;
+export declare function buildAnthropicThinkingProviderOptions(reasoning: Record<string, unknown> | undefined): {
     thinking?: {
         type: 'enabled';
-        budget_tokens: number;
+        budgetTokens: number;
     };
+    sendReasoning?: boolean;
 };
-export declare function buildGeminiThinkingConfig(reasoning: Record<string, unknown> | undefined): {
-    thinkingBudget: number;
-    includeThoughts: boolean;
+export declare function buildGeminiThinkingProviderOptions(reasoning: Record<string, unknown> | undefined): {
+    thinkingConfig: {
+        thinkingBudget: number;
+        includeThoughts: boolean;
+    };
+} | undefined;
+export declare function buildMoonshotThinkingProviderOptions(reasoning: Record<string, unknown> | undefined): {
+    thinking: {
+        type: 'enabled';
+        budgetTokens: number;
+    };
+} | undefined;
+export declare function buildDeepSeekThinkingProviderOptions(reasoning: Record<string, unknown> | undefined): {
+    thinking: {
+        type: 'enabled';
+    };
 } | undefined;

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

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

package/dist/dim-agent-sdk/src/providers/shared/usage.d.ts

@@ -1,2 +1,4 @@
-import type { Usage } from '../../contracts';
-export declare function normalizeUsage(raw: unknown): Usage | undefined;
+import type { LanguageModelV3FinishReason, LanguageModelV3Usage } from '@ai-sdk/provider';
+import type { ModelStopReason, Usage } from '../../contracts';
+export declare function normalizeLanguageModelUsage(raw: LanguageModelV3Usage | undefined): Usage | undefined;
+export declare function mapLanguageModelFinishReason(reason: LanguageModelV3FinishReason): ModelStopReason;

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

@@ -0,0 +1,11 @@
+import type { ConfiguredModelAdapter } from '../../contracts';
+import { type ProviderFactoryOptionsBase } from '../core/create-provider-factory';
+type FetchLike = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+export interface XaiAdapterOptions extends ProviderFactoryOptionsBase {
+    apiKey?: string;
+    baseUrl?: string;
+    fetch?: FetchLike;
+    headers?: Record<string, string>;
+}
+export declare const createXaiAdapter: (options: XaiAdapterOptions) => ConfiguredModelAdapter;
+export {};

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

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

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

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

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

@@ -0,0 +1,11 @@
+import type { ConfiguredModelAdapter } from '../../contracts';
+import { type ProviderFactoryOptionsBase } from '../core/create-provider-factory';
+type FetchLike = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+export interface XaiResponsesAdapterOptions extends ProviderFactoryOptionsBase {
+    apiKey?: string;
+    baseUrl?: string;
+    fetch?: FetchLike;
+    headers?: Record<string, string>;
+}
+export declare const createXaiResponsesAdapter: (options: XaiResponsesAdapterOptions) => ConfiguredModelAdapter;
+export {};

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

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

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

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

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

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

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

@@ -0,0 +1,13 @@
+import type { ConfiguredModelAdapter } from '../../contracts';
+import { type ProviderFactoryOptionsBase } from '../core/create-provider-factory';
+type FetchLike = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+export interface ZenMuxAdapterOptions extends ProviderFactoryOptionsBase {
+    apiKey?: string;
+    baseUrl?: string;
+    fetch?: FetchLike;
+    headers?: Record<string, string>;
+    organization?: string;
+    project?: string;
+}
+export declare const createZenMuxAdapter: (options: ZenMuxAdapterOptions) => ConfiguredModelAdapter;
+export {};

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

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

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

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

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

@@ -1,10 +1,10 @@
 export { ActivityTracker } from './activity';
-export { NodeExecGateway } from './ExecGateway';
-export { NodeFileSystemGateway } from './FileSystemGateway';
-export { DefaultGitGateway } from './GitGateway';
-export { DefaultModelGateway } from './ModelGateway';
-export { DefaultNetworkGateway } from './NetworkGateway';
+export { NodeExecGateway } from './exec-gateway';
+export { NodeFileSystemGateway } from './file-system-gateway';
+export { DefaultGitGateway } from './git-gateway';
+export { DefaultModelGateway } from './model-gateway';
+export { DefaultNetworkGateway } from './network-gateway';
 export { PermissionDeniedError, fullPermissions, normalizePermissions } from './permissions';
 export type { FileSystemPermission, PermissionSpec } from './permissions';
-export { PermissionGateway } from './PermissionGateway';
+export { PermissionGateway } from './permission-gateway';
 export type { AgentServices, ExecGateway, ExecOptions, ExecResult, FileSystemGateway, GitGateway, GlobOptions, GrepMatch, GrepOptions, ModelGateway, NetworkGateway, } from './types';

package/dist/dim-agent-sdk/src/tools/builtins/{EditTool.d.ts → edit-tool.d.ts}

@@ -1,5 +1,5 @@
 import type { CallToolResult, ToolExecutionContext } from '../../contracts/tool';
-import { BaseTool } from '../BaseTool';
+import { BaseTool } from '../base-tool';
 export declare class EditTool extends BaseTool {
     constructor();
     execute(args: Record<string, unknown>, context: ToolExecutionContext): Promise<CallToolResult>;

package/dist/dim-agent-sdk/src/tools/builtins/{ExecTool.d.ts → exec-tool.d.ts}

@@ -1,5 +1,5 @@
 import type { CallToolResult, ToolExecutionContext } from '../../contracts/tool';
-import { BaseTool } from '../BaseTool';
+import { BaseTool } from '../base-tool';
 export declare class ExecTool extends BaseTool {
     constructor();
     execute(args: Record<string, unknown>, context: ToolExecutionContext): Promise<CallToolResult>;

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

@@ -1,4 +1,4 @@
-export { EditTool } from './EditTool';
-export { ExecTool } from './ExecTool';
-export { ReadTool } from './ReadTool';
-export { WriteTool } from './WriteTool';
+export { EditTool } from './edit-tool';
+export { ExecTool } from './exec-tool';
+export { ReadTool } from './read-tool';
+export { WriteTool } from './write-tool';

package/dist/dim-agent-sdk/src/tools/builtins/{ReadTool.d.ts → read-tool.d.ts}

@@ -1,5 +1,5 @@
 import type { CallToolResult, ToolExecutionContext } from '../../contracts/tool';
-import { BaseTool } from '../BaseTool';
+import { BaseTool } from '../base-tool';
 export declare class ReadTool extends BaseTool {
     constructor();
     execute(args: Record<string, unknown>, context: ToolExecutionContext): Promise<CallToolResult>;

package/dist/dim-agent-sdk/src/tools/builtins/{WriteTool.d.ts → write-tool.d.ts}

@@ -1,5 +1,5 @@
 import type { CallToolResult, ToolExecutionContext } from '../../contracts/tool';
-import { BaseTool } from '../BaseTool';
+import { BaseTool } from '../base-tool';
 export declare class WriteTool extends BaseTool {
     constructor();
     execute(args: Record<string, unknown>, context: ToolExecutionContext): Promise<CallToolResult>;

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

@@ -1,4 +1,4 @@
-export { BaseTool } from './BaseTool';
+export { BaseTool } from './base-tool';
 export { errorToolResult, textToolResult } from './result';
-export { ToolRegistry } from './ToolRegistry';
+export { ToolRegistry } from './tool-registry';
 export * from './builtins';

package/dist/dim-plugin-api/src/index.d.ts

@@ -279,8 +279,24 @@ export interface Tool {
     readonly definition: ToolDefinition;
     execute(args: Record<string, unknown>, context: ToolExecutionContext): Promise<CallToolResult>;
 }
+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 SessionSnapshot {
-    schemaVersion: 1;
+    schemaVersion: 1 | 2;
     sessionId: string;
     model?: ModelRef;
     cwd?: string;
@@ -291,6 +307,7 @@ export interface SessionSnapshot {
     createdAt: number;
     updatedAt: number;
     metadata?: Record<string, unknown>;
+    messageQueue?: MessageQueueSnapshot;
 }
 export interface SessionStatus {
     sessionId: string;