@archships/dim-agent-sdk 0.0.1

package/dist/persistence/FileStateStore.d.ts

@@ -0,0 +1,14 @@
+import type { SessionSnapshot } from '../contracts/state';
+import type { StateStore } from './store';
+export interface FileStateStoreOptions {
+    directory: string;
+}
+export declare class FileStateStore implements StateStore {
+    readonly directory: string;
+    constructor(options: FileStateStoreOptions);
+    save(snapshot: SessionSnapshot): Promise<void>;
+    load(sessionId: string): Promise<SessionSnapshot | null>;
+    delete(sessionId: string): Promise<void>;
+    list(): Promise<SessionSnapshot[]>;
+    private filePath;
+}

package/dist/persistence/InMemoryStateStore.d.ts

@@ -0,0 +1,9 @@
+import type { SessionSnapshot } from '../contracts/state';
+import type { StateStore } from './store';
+export declare class InMemoryStateStore implements StateStore {
+    private readonly snapshots;
+    save(snapshot: SessionSnapshot): Promise<void>;
+    load(sessionId: string): Promise<SessionSnapshot | null>;
+    delete(sessionId: string): Promise<void>;
+    list(): Promise<SessionSnapshot[]>;
+}

package/dist/persistence/SnapshotCodec.d.ts

@@ -0,0 +1,20 @@
+import type { Message, ModelRef, SessionSnapshot, Usage } from '../contracts';
+export interface SnapshotCodecInput {
+    sessionId: string;
+    model?: ModelRef;
+    cwd?: string;
+    messages: Message[];
+    usage?: Usage;
+    createdAt: number;
+    updatedAt: number;
+    metadata?: Record<string, unknown>;
+}
+export interface SnapshotCodec {
+    encode(input: SnapshotCodecInput): SessionSnapshot;
+    decode(value: unknown): SessionSnapshot;
+}
+export declare class JsonSnapshotCodec implements SnapshotCodec {
+    encode(input: SnapshotCodecInput): SessionSnapshot;
+    decode(value: unknown): SessionSnapshot;
+}
+export declare const sessionSnapshotCodec: JsonSnapshotCodec;

package/dist/persistence/index.d.ts

@@ -0,0 +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 type { StateStore } from './store';

package/dist/persistence/store.d.ts

@@ -0,0 +1,7 @@
+import type { SessionSnapshot } from '../contracts/state';
+export interface StateStore {
+    save(snapshot: SessionSnapshot): Promise<void>;
+    load(sessionId: string): Promise<SessionSnapshot | null>;
+    delete(sessionId: string): Promise<void>;
+    list(): Promise<SessionSnapshot[]>;
+}

package/dist/plugin-host/HookPipeline.d.ts

@@ -0,0 +1,7 @@
+import type { HookName, HookPayloadMap, HookRegistration, PluginRuntimeContext } from './types';
+export declare class HookPipeline {
+    private readonly registrations;
+    register(pluginId: string, priority: number, hooks?: HookRegistration): void;
+    runMiddleware<N extends HookName>(name: N, payload: HookPayloadMap[N], context: PluginRuntimeContext): Promise<HookPayloadMap[N]>;
+    runObservers<N extends HookName>(name: N, payload: HookPayloadMap[N], context: PluginRuntimeContext): Promise<void>;
+}

package/dist/plugin-host/PluginHost.d.ts

@@ -0,0 +1,36 @@
+import type { ContextItem } from '../context';
+import { PermissionGateway } from '../services';
+import type { ActivityTracker, AgentServices } from '../services';
+import type { Tool } from '../contracts';
+import { HookPipeline } from './HookPipeline';
+import type { ContextContributorInput, DimPlugin, PluginRuntimeContext, PromptContributorInput } from './types';
+export interface PluginHostOptions {
+    agentId: string;
+    cwd?: string;
+    plugins?: DimPlugin[];
+    services: AgentServices;
+    permissionGateway: PermissionGateway;
+    tracker?: ActivityTracker;
+}
+export declare class PluginHost {
+    readonly pipeline: HookPipeline;
+    private readonly contextContributors;
+    private readonly promptContributors;
+    private readonly tools;
+    private readonly services;
+    private readonly cwd?;
+    private readonly agentId;
+    private readonly tracker?;
+    constructor(options: PluginHostOptions);
+    pluginTools(): Tool[];
+    recentFiles(limit?: number): string[];
+    runMiddleware<N extends keyof import('./types').HookPayloadMap>(name: N, payload: import('./types').HookPayloadMap[N], context?: Omit<PluginRuntimeContext, 'agentId' | 'services'> & {
+        services?: AgentServices;
+    }): Promise<import('./types').HookPayloadMap[N]>;
+    runObservers<N extends keyof import('./types').HookPayloadMap>(name: N, payload: import('./types').HookPayloadMap[N], context?: Omit<PluginRuntimeContext, 'agentId' | 'services'> & {
+        services?: AgentServices;
+    }): Promise<void>;
+    collectContext(input: ContextContributorInput): Promise<ContextItem[]>;
+    collectPromptSegments(input: PromptContributorInput): Promise<string[]>;
+    private createRuntimeContext;
+}

package/dist/plugin-host/helpers.d.ts

@@ -0,0 +1,3 @@
+import type { HookControlResult } from '@archships/dim-plugin-api';
+export { continueHook, replaceHook, stopHook } from '@archships/dim-plugin-api';
+export declare function isHookControlResult<T>(value: unknown): value is HookControlResult<T>;

package/dist/plugin-host/index.d.ts

@@ -0,0 +1,4 @@
+export { continueHook, replaceHook, stopHook } from './helpers';
+export { HookPipeline } from './HookPipeline';
+export { PluginHost } from './PluginHost';
+export type { AgentMode, ContextContributor, ContextContributorInput, DimPlugin, HookControlResult, HookHandler, HookMiddleware, HookName, HookObserver, HookPayloadMap, HookRegistration, PluginContext, PluginManifest, PluginRuntimeContext, PluginSetupResult, PromptContributor, PromptContributorInput, } from './types';

package/dist/plugin-host/types.d.ts

@@ -0,0 +1 @@
+export type { AgentMode, CallToolResult, ContextContributor, ContextContributorInput, ContextItem, DimPlugin, HookControlResult, HookHandler, HookMiddleware, HookName, HookObserver, HookPayloadMap, HookRegistration, PermissionSpec, PluginContext, PluginManifest, PluginRuntimeContext, PluginServices, PluginSetupResult, PromptContributor, PromptContributorInput, Tool, ToolCall, ToolDefinition, } from '@archships/dim-plugin-api';

package/dist/providers/anthropic/adapter.d.ts

@@ -0,0 +1,13 @@
+import type { ConfiguredModelAdapter } from '../../contracts';
+type FetchLike = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+export interface AnthropicAdapterOptions {
+    apiKey?: string;
+    baseUrl?: string;
+    defaultModel: string;
+    provider?: string;
+    fetch?: FetchLike;
+    headers?: Record<string, string>;
+    anthropicVersion?: string;
+}
+export declare function createAnthropicAdapter(options: AnthropicAdapterOptions): ConfiguredModelAdapter;
+export {};

package/dist/providers/anthropic/mapper.d.ts

@@ -0,0 +1,28 @@
+import type { Message, ModelStopReason, ToolDefinition } from '../../contracts';
+import type { RawToolCallPayload } from '../shared/tool-call';
+export type AnthropicThinkingBlock = {
+    type: 'thinking';
+    thinking?: string;
+    signature?: string;
+} | {
+    type: 'redacted_thinking';
+    data?: string;
+};
+export type AnthropicContentBlock = {
+    type: 'text';
+    text?: string;
+} | AnthropicThinkingBlock | {
+    type: 'tool_use';
+    id?: string;
+    name?: string;
+    input?: Record<string, unknown>;
+};
+export declare function mapToolDefinitionsToAnthropic(tools: ToolDefinition[] | undefined): unknown[] | undefined;
+export declare function mapAnthropicStopReason(reason: unknown, toolCallCount: number): ModelStopReason;
+export declare function messagesToAnthropic(messages: Message[]): {
+    system?: string;
+    messages: unknown[];
+};
+export declare function normalizeAnthropicToolCalls(value: AnthropicContentBlock[] | undefined): RawToolCallPayload[];
+export declare function extractAnthropicThinking(value: AnthropicContentBlock[] | undefined): string[];
+export declare function createAnthropicThinkingState(value: AnthropicContentBlock[] | undefined): Record<string, unknown> | undefined;

package/dist/providers/gemini/adapter.d.ts

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

package/dist/providers/gemini/mapper.d.ts

@@ -0,0 +1,30 @@
+import type { Message, ModelStopReason, ToolDefinition } from '../../contracts';
+import type { RawToolCallPayload } from '../shared/tool-call';
+export type GeminiPart = {
+    text?: string;
+    thought?: boolean;
+    thoughtSignature?: string;
+} | {
+    functionCall?: {
+        name?: string;
+        args?: Record<string, unknown>;
+    };
+    thought?: boolean;
+    thoughtSignature?: string;
+};
+export declare function mapToolDefinitionsToGemini(tools: ToolDefinition[] | undefined): {
+    tools?: unknown[];
+    toolConfig?: unknown;
+};
+export declare function mapGeminiStopReason(reason: unknown, toolCallCount: number): ModelStopReason;
+export declare function messagesToGemini(messages: Message[]): {
+    contents: unknown[];
+    systemInstruction?: {
+        parts: Array<{
+            text: string;
+        }>;
+    };
+};
+export declare function normalizeGeminiToolCalls(value: GeminiPart[] | undefined): RawToolCallPayload[];
+export declare function extractGeminiThinking(value: GeminiPart[] | undefined): string[];
+export declare function createGeminiThoughtState(value: GeminiPart[] | undefined): Record<string, unknown> | undefined;

package/dist/providers/index.d.ts

@@ -0,0 +1,8 @@
+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';

package/dist/providers/openai/adapter.d.ts

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

package/dist/providers/openai/mapper.d.ts

@@ -0,0 +1,15 @@
+import type { ContentBlock, Message, ModelStopReason, ToolDefinition } from '../../contracts';
+import type { RawToolCallPayload } from '../shared/tool-call';
+export declare function mapToolDefinitionsToOpenAI(tools: ToolDefinition[] | undefined): unknown[] | undefined;
+export declare function mapOpenAIStopReason(reason: unknown, toolCallCount: number): ModelStopReason;
+export declare function messageContentToOpenAI(content: ContentBlock[]): string | Array<Record<string, unknown>>;
+export declare function messagesToOpenAI(messages: Message[]): unknown[];
+type OpenAIToolCallPayload = {
+    id?: string;
+    function?: {
+        name?: string;
+        arguments?: string;
+    };
+};
+export declare function normalizeOpenAIToolCalls(value: OpenAIToolCallPayload[] | undefined): RawToolCallPayload[];
+export {};

package/dist/providers/openai-responses/adapter.d.ts

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

package/dist/providers/openai-responses/mapper.d.ts

@@ -0,0 +1,40 @@
+import type { Message, ModelStopReason } from '../../contracts';
+import type { RawToolCallPayload } from '../shared/tool-call';
+export interface OpenAIResponsesRequestPayload {
+    instructions?: string;
+    input: unknown[];
+    previousResponseId?: string;
+}
+export interface OpenAIResponsesTextPart {
+    type?: string;
+    text?: string;
+}
+export interface OpenAIResponsesOutputItem {
+    type?: string;
+    id?: string;
+    call_id?: string;
+    name?: string;
+    arguments?: string | Record<string, unknown>;
+    role?: string;
+    encrypted_content?: string | null;
+    summary?: Array<{
+        type?: string;
+        text?: string;
+    }>;
+    content?: OpenAIResponsesTextPart[];
+}
+export type OpenAIResponsesState = Record<string, unknown> & {
+    responseId: string;
+};
+export declare function mapToolDefinitionsToOpenAIResponses(tools: import('../../contracts').ToolDefinition[] | undefined): unknown[] | undefined;
+export declare function mapOpenAIResponsesStopReason(response: {
+    status?: string;
+    incomplete_details?: {
+        reason?: string | null;
+    };
+} | undefined, toolCallCount: number): ModelStopReason;
+export declare function messagesToOpenAIResponses(messages: Message[]): OpenAIResponsesRequestPayload;
+export declare function normalizeOpenAIResponsesToolCalls(output: OpenAIResponsesOutputItem[] | undefined): RawToolCallPayload[];
+export declare function extractOpenAIResponsesText(output: OpenAIResponsesOutputItem[] | undefined): string[];
+export declare function extractOpenAIResponsesThinking(output: OpenAIResponsesOutputItem[] | undefined): string[];
+export declare function createOpenAIResponsesState(responseId: string | undefined): OpenAIResponsesState | undefined;

package/dist/providers/shared/http-error.d.ts

@@ -0,0 +1,7 @@
+import type { ModelErrorPayload } from '../../contracts';
+export declare function createHttpErrorPayload(input: {
+    code: string;
+    provider: string;
+    endpoint: string;
+    response: Response;
+}): Promise<ModelErrorPayload>;

package/dist/providers/shared/provider-state.d.ts

@@ -0,0 +1,4 @@
+import type { Message } from '../../contracts';
+export declare const PROVIDER_STATE_METADATA_KEY = "_dimProviderState";
+export declare function attachProviderState(metadata: Record<string, unknown> | undefined, provider: string, state: Record<string, unknown> | undefined): Record<string, unknown> | undefined;
+export declare function readProviderState(message: Message, provider: string): Record<string, unknown> | undefined;

package/dist/providers/shared/reasoning.d.ts

@@ -0,0 +1,14 @@
+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;
+    thinking?: {
+        type: 'enabled';
+        budget_tokens: number;
+    };
+};
+export declare function buildGeminiThinkingConfig(reasoning: Record<string, unknown> | undefined): {
+    thinkingBudget: number;
+    includeThoughts: boolean;
+} | undefined;

package/dist/providers/shared/tool-call.d.ts

@@ -0,0 +1,5 @@
+export interface RawToolCallPayload {
+    id: string;
+    name: string;
+    argsText: string;
+}

package/dist/providers/shared/usage.d.ts

@@ -0,0 +1,2 @@
+import type { Usage } from '../../contracts';
+export declare function normalizeUsage(raw: unknown): Usage | undefined;

package/dist/services/ExecGateway.d.ts

@@ -0,0 +1,14 @@
+import { ActivityTracker } from './activity';
+import type { ExecGateway, ExecOptions, ExecResult } from './types';
+export interface ExecGatewayOptions {
+    cwd?: string;
+    env?: Record<string, string>;
+    tracker?: ActivityTracker;
+}
+export declare class NodeExecGateway implements ExecGateway {
+    private readonly cwd?;
+    private readonly env;
+    private readonly tracker?;
+    constructor(options?: ExecGatewayOptions);
+    execute(command: string, options?: ExecOptions): Promise<ExecResult>;
+}

package/dist/services/FileSystemGateway.d.ts

@@ -0,0 +1,35 @@
+import { ActivityTracker } from './activity';
+import type { FileSystemGateway, GlobOptions, GrepMatch, GrepOptions } from './types';
+export interface FileSystemGatewayOptions {
+    cwd?: string;
+    tracker?: ActivityTracker;
+}
+export declare class NodeFileSystemGateway implements FileSystemGateway {
+    private readonly cwd?;
+    private readonly tracker?;
+    constructor(options?: FileSystemGatewayOptions);
+    readText(targetPath: string, options?: {
+        cwd?: string;
+    }): Promise<string>;
+    writeText(targetPath: string, content: string, options?: {
+        cwd?: string;
+    }): Promise<{
+        path: string;
+        bytes: number;
+    }>;
+    editText(targetPath: string, options: {
+        oldText: string;
+        newText: string;
+        replaceAll?: boolean;
+        cwd?: string;
+    }): Promise<{
+        path: string;
+        replacements: number;
+    }>;
+    exists(targetPath: string, options?: {
+        cwd?: string;
+    }): Promise<boolean>;
+    glob(pattern: string, options?: GlobOptions): Promise<string[]>;
+    grep(query: string, options?: GrepOptions): Promise<GrepMatch[]>;
+    private recordFile;
+}

package/dist/services/GitGateway.d.ts

@@ -0,0 +1,17 @@
+import type { ExecGateway, GitGateway } from './types';
+export interface GitGatewayOptions {
+    exec: ExecGateway;
+    cwd?: string;
+}
+export declare class DefaultGitGateway implements GitGateway {
+    private readonly exec;
+    private readonly cwd?;
+    constructor(options: GitGatewayOptions);
+    status(options?: {
+        cwd?: string;
+    }): Promise<string | null>;
+    diff(options?: {
+        cwd?: string;
+    }): Promise<string | null>;
+    private runGitCommand;
+}

package/dist/services/ModelGateway.d.ts

@@ -0,0 +1,7 @@
+import type { ModelClient, ModelRequest, ModelStreamEvent } from '../contracts';
+import type { ModelGateway } from './types';
+export declare class DefaultModelGateway implements ModelGateway {
+    private readonly model;
+    constructor(model: ModelClient);
+    stream(request: ModelRequest): AsyncIterable<ModelStreamEvent>;
+}

package/dist/services/NetworkGateway.d.ts

@@ -0,0 +1,6 @@
+import type { NetworkGateway } from './types';
+export declare class DefaultNetworkGateway implements NetworkGateway {
+    private readonly fetchImpl;
+    constructor(fetchImpl?: typeof fetch);
+    fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+}

package/dist/services/PermissionGateway.d.ts

@@ -0,0 +1,11 @@
+import type { AgentServices } from './types';
+import type { PermissionSpec } from './permissions';
+export interface PermissionGatewayOptions {
+    permissions?: PermissionSpec;
+}
+export declare class PermissionGateway {
+    private readonly permissions;
+    constructor(options?: PermissionGatewayOptions);
+    get agentPermissions(): PermissionSpec;
+    scopeServices(services: AgentServices, pluginId: string, requested?: PermissionSpec): AgentServices;
+}

package/dist/services/activity.d.ts

@@ -0,0 +1,10 @@
+export interface ActivityRecord {
+    type: 'file' | 'command';
+    label: string;
+    timestamp: number;
+}
+export declare class ActivityTracker {
+    private readonly records;
+    record(record: ActivityRecord): void;
+    recentFiles(limit?: number): string[];
+}

package/dist/services/index.d.ts

@@ -0,0 +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 { PermissionDeniedError, fullPermissions, normalizePermissions } from './permissions';
+export type { FileSystemPermission, PermissionSpec } from './permissions';
+export { PermissionGateway } from './PermissionGateway';
+export type { AgentServices, ExecGateway, ExecOptions, ExecResult, FileSystemGateway, GitGateway, GlobOptions, GrepMatch, GrepOptions, ModelGateway, NetworkGateway, } from './types';

package/dist/services/permissions.d.ts

@@ -0,0 +1,17 @@
+export type FileSystemPermission = boolean | 'read' | 'write' | 'full';
+export interface PermissionSpec {
+    fs?: FileSystemPermission;
+    git?: boolean;
+    network?: boolean;
+    process?: boolean;
+    model?: boolean;
+    mcp?: boolean;
+}
+export declare const fullPermissions: PermissionSpec;
+export declare class PermissionDeniedError extends Error {
+    readonly code = "permission_denied";
+    constructor(message: string);
+}
+export declare function normalizePermissions(input?: PermissionSpec): PermissionSpec;
+export declare function canReadFs(permissions: PermissionSpec): boolean;
+export declare function canWriteFs(permissions: PermissionSpec): boolean;

package/dist/services/types.d.ts

@@ -0,0 +1,77 @@
+import type { ModelRequest, ModelStreamEvent } from '../contracts';
+export interface ExecOptions {
+    cwd?: string;
+    env?: Record<string, string>;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}
+export interface ExecResult {
+    command: string;
+    cwd: string | null;
+    stdout: string;
+    stderr: string;
+    exitCode: number | null;
+    signal: string | null;
+    timedOut?: boolean;
+}
+export interface GlobOptions {
+    cwd?: string;
+    limit?: number;
+}
+export interface GrepOptions extends GlobOptions {
+    pattern?: string;
+}
+export interface GrepMatch {
+    path: string;
+    lineNumber: number;
+    line: string;
+}
+export interface FileSystemGateway {
+    readText(path: string, options?: {
+        cwd?: string;
+    }): Promise<string>;
+    writeText(path: string, content: string, options?: {
+        cwd?: string;
+    }): Promise<{
+        path: string;
+        bytes: number;
+    }>;
+    editText(path: string, options: {
+        oldText: string;
+        newText: string;
+        replaceAll?: boolean;
+        cwd?: string;
+    }): Promise<{
+        path: string;
+        replacements: number;
+    }>;
+    exists(path: string, options?: {
+        cwd?: string;
+    }): Promise<boolean>;
+    glob(pattern: string, options?: GlobOptions): Promise<string[]>;
+    grep(query: string, options?: GrepOptions): Promise<GrepMatch[]>;
+}
+export interface ExecGateway {
+    execute(command: string, options?: ExecOptions): Promise<ExecResult>;
+}
+export interface GitGateway {
+    status(options?: {
+        cwd?: string;
+    }): Promise<string | null>;
+    diff(options?: {
+        cwd?: string;
+    }): Promise<string | null>;
+}
+export interface NetworkGateway {
+    fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+}
+export interface ModelGateway {
+    stream(request: ModelRequest): AsyncIterable<ModelStreamEvent>;
+}
+export interface AgentServices {
+    fileSystem: FileSystemGateway;
+    exec: ExecGateway;
+    git: GitGateway;
+    network: NetworkGateway;
+    model: ModelGateway;
+}

package/dist/tools/BaseTool.d.ts

@@ -0,0 +1,6 @@
+import type { CallToolResult, Tool, ToolDefinition, ToolExecutionContext } from '../contracts/tool';
+export declare abstract class BaseTool implements Tool {
+    readonly definition: ToolDefinition;
+    constructor(definition: ToolDefinition);
+    abstract execute(args: Record<string, unknown>, context: ToolExecutionContext): Promise<CallToolResult>;
+}

package/dist/tools/ToolRegistry.d.ts

@@ -0,0 +1,9 @@
+import type { Tool, ToolDefinition } from '../contracts/tool';
+export declare class ToolRegistry {
+    private readonly tools;
+    register(tool: Tool): this;
+    unregister(name: string): boolean;
+    get(name: string): Tool | undefined;
+    list(): Tool[];
+    definitions(): ToolDefinition[];
+}

package/dist/tools/builtins/EditTool.d.ts

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

package/dist/tools/builtins/ExecTool.d.ts

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

package/dist/tools/builtins/ReadTool.d.ts

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

package/dist/tools/builtins/WriteTool.d.ts

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

package/dist/tools/builtins/index.d.ts

@@ -0,0 +1,4 @@
+export { EditTool } from './EditTool';
+export { ExecTool } from './ExecTool';
+export { ReadTool } from './ReadTool';
+export { WriteTool } from './WriteTool';

package/dist/tools/builtins/utils.d.ts

@@ -0,0 +1,6 @@
+export declare function resolvePathFromCwd(cwd: string | undefined, targetPath: string): string;
+export declare function readStringArg(args: Record<string, unknown>, key: string, options?: {
+    allowEmpty?: boolean;
+}): string;
+export declare function readOptionalBooleanArg(args: Record<string, unknown>, key: string): boolean | undefined;
+export declare function readOptionalNumberArg(args: Record<string, unknown>, key: string): number | undefined;

package/dist/tools/index.d.ts

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