@primo-ai/core 0.1.2 → 0.1.4

package/dist/agent.d.ts

@@ -40,6 +40,7 @@ export declare class Agent {
     private orchestrator;
     private sessionManager?;
     private contextBuilder;
+    private activeAbortController;
     constructor(config: AgentConfig, deps?: AgentDependencies);
     use(factory: Processor | PluginFactory): void;
     teardown(): Promise<void>;
@@ -54,6 +55,18 @@ export declare class Agent {
     resume(sessionId: string, signal?: globalThis.AbortSignal): Promise<AgentRunResult>;
     stream(input: string, signal?: globalThis.AbortSignal): AsyncGenerator<string>;
     streamEvents(input: string, signal?: globalThis.AbortSignal): AsyncGenerator<import('@primo-ai/sdk').StreamEvent>;
+    /** Abort a running agent. Idempotent — no-op if agent is not running. */
+    abort(): void;
+    /**
+     * Continue an existing session by restoring its context and running the pipeline
+     * with a new user message.
+     */
+    continue(sessionId: string, message: string, signal?: globalThis.AbortSignal): Promise<AgentRunResult>;
+    /**
+     * Continue an existing session with streaming. Yields StreamEvents for the
+     * continued conversation.
+     */
+    continueStream(sessionId: string, message: string, signal?: globalThis.AbortSignal): AsyncGenerator<import('@primo-ai/sdk').StreamEvent>;
     /** Clear the cached model so the next run re-resolves from the factory. */
     invalidateModel(): void;
     /** Auto-invalidate cached model when the error indicates auth failure or model-not-found. */
@@ -63,4 +76,3 @@ export declare class Agent {
     private registerTools;
     private registerBuiltinProcessors;
 }
-//# sourceMappingURL=agent.d.ts.map

package/dist/agent.js

@@ -22,6 +22,7 @@ export class Agent {
     orchestrator;
     sessionManager;
     contextBuilder;
+    activeAbortController = null;
     constructor(config, deps) {
         this.config = config;
         this.modelFactory = deps?.modelFactory ?? new ModelFactory();
@@ -83,10 +84,15 @@ export class Agent {
         // agent.start hook
         await hm.invoke('agent.start', { sessionId: context.request.sessionId, request: context.request, agentConfig: this.config }, {});
         const maxIter = typeof this.config.maxIterations === 'number' ? this.config.maxIterations : 10;
+        const controller = new AbortController();
+        this.activeAbortController = controller;
+        if (signal) {
+            signal.addEventListener('abort', () => controller.abort(), { once: true });
+        }
         try {
             const { context: finalCtx, compatRetries } = await this.orchestrator.runLoop(context, {
                 maxIterations: maxIter,
-                signal,
+                signal: controller.signal,
                 modelString: this.config.model,
                 sessionId: context.request.sessionId,
                 autoCheckpoint: this._autoCheckpoint,
@@ -103,6 +109,7 @@ export class Agent {
             throw error;
         }
         finally {
+            this.activeAbortController = null;
             // agent.end hook — always fires, even on error; suppress hook errors to preserve original
             try {
                 await hm.invoke('agent.end', { sessionId: context.request.sessionId }, {});
@@ -149,16 +156,22 @@ export class Agent {
         // agent.start hook
         await hm.invoke('agent.start', { sessionId: context.request.sessionId, request: context.request, agentConfig: this.config }, {});
         const maxIter = typeof this.config.maxIterations === 'number' ? this.config.maxIterations : 10;
+        const controller = new AbortController();
+        this.activeAbortController = controller;
+        if (signal) {
+            signal.addEventListener('abort', () => controller.abort(), { once: true });
+        }
         try {
             yield* this.orchestrator.streamLoop(context, {
                 maxIterations: maxIter,
-                signal,
+                signal: controller.signal,
                 modelString: this.config.model,
                 sessionId: context.request.sessionId,
                 autoCheckpoint: this._autoCheckpoint,
             });
         }
         finally {
+            this.activeAbortController = null;
             try {
                 await hm.invoke('agent.end', { sessionId: context.request.sessionId }, {});
             }
@@ -172,16 +185,128 @@ export class Agent {
         const hm = this._pluginManager.hookManager;
         await hm.invoke('agent.start', { sessionId: context.request.sessionId, request: context.request, agentConfig: this.config }, {});
         const maxIter = typeof this.config.maxIterations === 'number' ? this.config.maxIterations : 10;
+        const controller = new AbortController();
+        this.activeAbortController = controller;
+        if (signal) {
+            signal.addEventListener('abort', () => controller.abort(), { once: true });
+        }
         try {
             yield* this.orchestrator.streamEvents(context, {
                 maxIterations: maxIter,
-                signal,
+                signal: controller.signal,
+                modelString: this.config.model,
+                sessionId: context.request.sessionId,
+                autoCheckpoint: this._autoCheckpoint,
+            });
+        }
+        finally {
+            this.activeAbortController = null;
+            try {
+                await hm.invoke('agent.end', { sessionId: context.request.sessionId }, {});
+            }
+            catch { /* hook error must not mask original */ }
+        }
+    }
+    /** Abort a running agent. Idempotent — no-op if agent is not running. */
+    abort() {
+        if (!this.orchestrator.stateMachine.canTransition('cancelled'))
+            return;
+        this.orchestrator.stateMachine.transition('cancelled');
+        this.activeAbortController?.abort();
+        this.activeAbortController = null;
+    }
+    /**
+     * Continue an existing session by restoring its context and running the pipeline
+     * with a new user message.
+     */
+    async continue(sessionId, message, signal) {
+        if (signal?.aborted)
+            throw new DOMException('Agent continue aborted', 'AbortError');
+        if (!this.sessionManager)
+            throw new Error('Session manager is required for continue()');
+        const context = await this.sessionManager.restore(sessionId);
+        context.request.input = message;
+        if (context.session.messageHistory) {
+            context.session.messageHistory.push({ role: 'user', content: message });
+        }
+        else {
+            context.session.messageHistory = [{ role: 'user', content: message }];
+        }
+        context.iteration = { step: 0 };
+        this._pluginManager.freezeHarnessInstances();
+        const hm = this._pluginManager.hookManager;
+        await hm.invoke('agent.start', { sessionId: context.request.sessionId, request: context.request, agentConfig: this.config }, {});
+        const maxIter = typeof this.config.maxIterations === 'number' ? this.config.maxIterations : 10;
+        const controller = new AbortController();
+        this.activeAbortController = controller;
+        if (signal) {
+            signal.addEventListener('abort', () => controller.abort(), { once: true });
+        }
+        try {
+            const { context: finalCtx, compatRetries } = await this.orchestrator.runLoop(context, {
+                maxIterations: maxIter,
+                signal: controller.signal,
+                modelString: this.config.model,
+                sessionId: context.request.sessionId,
+                autoCheckpoint: this._autoCheckpoint,
+            });
+            return {
+                response: finalCtx.iteration.response ?? '',
+                tokenUsage: finalCtx.session.totalTokenUsage ?? { input: 0, output: 0 },
+                sessionId: context.request.sessionId,
+                compatRetries,
+            };
+        }
+        catch (error) {
+            this.autoInvalidateModel(error);
+            throw error;
+        }
+        finally {
+            this.activeAbortController = null;
+            try {
+                await hm.invoke('agent.end', { sessionId: context.request.sessionId }, {});
+            }
+            catch { /* hook error must not mask original */ }
+        }
+    }
+    /**
+     * Continue an existing session with streaming. Yields StreamEvents for the
+     * continued conversation.
+     */
+    async *continueStream(sessionId, message, signal) {
+        if (signal?.aborted)
+            throw new DOMException('Agent continue stream aborted', 'AbortError');
+        if (!this.sessionManager)
+            throw new Error('Session manager is required for continueStream()');
+        const context = await this.sessionManager.restore(sessionId);
+        context.request.input = message;
+        if (context.session.messageHistory) {
+            context.session.messageHistory.push({ role: 'user', content: message });
+        }
+        else {
+            context.session.messageHistory = [{ role: 'user', content: message }];
+        }
+        context.iteration = { step: 0 };
+        this._pluginManager.freezeHarnessInstances();
+        const hm = this._pluginManager.hookManager;
+        await hm.invoke('agent.start', { sessionId: context.request.sessionId, request: context.request, agentConfig: this.config }, {});
+        const maxIter = typeof this.config.maxIterations === 'number' ? this.config.maxIterations : 10;
+        const controller = new AbortController();
+        this.activeAbortController = controller;
+        if (signal) {
+            signal.addEventListener('abort', () => controller.abort(), { once: true });
+        }
+        try {
+            yield* this.orchestrator.streamEvents(context, {
+                maxIterations: maxIter,
+                signal: controller.signal,
                 modelString: this.config.model,
                 sessionId: context.request.sessionId,
                 autoCheckpoint: this._autoCheckpoint,
             });
         }
         finally {
+            this.activeAbortController = null;
             try {
                 await hm.invoke('agent.end', { sessionId: context.request.sessionId }, {});
             }
@@ -257,4 +382,3 @@ function isAuthOrNotFoundError(error) {
     const code = err.statusCode ?? err.status;
     return code === 401 || code === 403 || code === 404;
 }
-//# sourceMappingURL=agent.js.map

package/dist/checkpoint-store.d.ts

@@ -16,4 +16,3 @@ export declare class JsonlCheckpointStore<T = unknown> implements CheckpointStor
     delete(sessionId: string): Promise<void>;
     list(): Promise<string[]>;
 }
-//# sourceMappingURL=checkpoint-store.d.ts.map

package/dist/checkpoint-store.js

@@ -76,4 +76,3 @@ export class JsonlCheckpointStore {
         }
     }
 }
-//# sourceMappingURL=checkpoint-store.js.map

package/dist/concurrency-controller.d.ts

@@ -6,4 +6,3 @@ export declare class ConcurrencyController {
     getActiveCount(slotKey: string): number;
     private releaseSlot;
 }
-//# sourceMappingURL=concurrency-controller.d.ts.map

package/dist/concurrency-controller.js

@@ -68,4 +68,3 @@ export class ConcurrencyController {
         }
     }
 }
-//# sourceMappingURL=concurrency-controller.js.map

package/dist/config-merge.d.ts

@@ -9,4 +9,3 @@
  * - The target is NOT mutated; a new object is returned.
  */
 export declare function deepMerge(target: Record<string, unknown>, ...sources: Record<string, unknown>[]): Record<string, unknown>;
-//# sourceMappingURL=config-merge.d.ts.map

package/dist/config-merge.js

@@ -44,4 +44,3 @@ export function deepMerge(target, ...sources) {
 function isObject(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
-//# sourceMappingURL=config-merge.js.map

package/dist/config.d.ts

@@ -13,4 +13,3 @@ export declare class ConfigLoader {
     parseJsonc(content: string): Record<string, unknown>;
     load(sources: ConfigSource): Promise<HarnessConfig>;
 }
-//# sourceMappingURL=config.d.ts.map

package/dist/config.js

@@ -141,4 +141,3 @@ const HarnessConfigSchema = z.object({
         apiKey: z.string().optional(),
     })).optional(),
 }).passthrough();
-//# sourceMappingURL=config.js.map

package/dist/context-builder.d.ts

@@ -26,4 +26,3 @@ export declare class ContextBuilder {
     private countToolDeclarations;
     private matchProfile;
 }
-//# sourceMappingURL=context-builder.d.ts.map

package/dist/context-builder.js

@@ -175,4 +175,3 @@ export class ContextBuilder {
         return undefined;
     }
 }
-//# sourceMappingURL=context-builder.js.map

package/dist/dynamic-resolver.d.ts

@@ -4,4 +4,3 @@ import type { Dynamic, ResolveContext } from '@primo-ai/sdk';
  * otherwise return the static value as-is.
  */
 export declare function resolveDynamic<T>(value: Dynamic<T>, ctx: ResolveContext): Promise<T>;
-//# sourceMappingURL=dynamic-resolver.d.ts.map

package/dist/dynamic-resolver.js

@@ -8,4 +8,3 @@ export async function resolveDynamic(value, ctx) {
     }
     return value;
 }
-//# sourceMappingURL=dynamic-resolver.js.map

package/dist/errors.d.ts

@@ -27,4 +27,3 @@ export declare class ModelNotFoundError extends FatalError {
 export declare class ToolExecutionError extends RecoverableError {
     constructor(message: string, cause?: Error);
 }
-//# sourceMappingURL=errors.d.ts.map

package/dist/errors.js

@@ -37,4 +37,3 @@ export class ToolExecutionError extends RecoverableError {
         super(message, { code: 'TOOL_ERROR', cause });
     }
 }
-//# sourceMappingURL=errors.js.map

package/dist/event-bus.d.ts

@@ -4,5 +4,5 @@ export declare class EventBus {
     constructor(onError?: ((error: unknown, eventType: string) => void) | undefined);
     emit(eventType: string, data?: unknown): void;
     subscribe(eventType: string, handler: (data?: unknown) => void): () => void;
+    once(eventType: string): Promise<unknown>;
 }
-//# sourceMappingURL=event-bus.d.ts.map

package/dist/event-bus.js

@@ -32,5 +32,12 @@ export class EventBus {
         set.add(handler);
         return () => set.delete(handler);
     }
+    once(eventType) {
+        return new Promise((resolve) => {
+            const unsub = this.subscribe(eventType, (data) => {
+                unsub();
+                resolve(data);
+            });
+        });
+    }
 }
-//# sourceMappingURL=event-bus.js.map

package/dist/event-system.d.ts

@@ -16,4 +16,3 @@ export declare class EventSystem {
     replay(sessionId: string, options?: ReplayOptions): Promise<void>;
     private filterEvents;
 }
-//# sourceMappingURL=event-system.d.ts.map

package/dist/event-system.js

@@ -55,4 +55,3 @@ export class EventSystem {
         return result;
     }
 }
-//# sourceMappingURL=event-system.js.map

package/dist/fallback-runner.d.ts

@@ -27,4 +27,3 @@ export declare class FallbackRunner {
         tokenUsage: TokenUsage;
     }>;
 }
-//# sourceMappingURL=fallback-runner.d.ts.map

package/dist/fallback-runner.js

@@ -37,4 +37,3 @@ export class FallbackRunner {
         throw lastError;
     }
 }
-//# sourceMappingURL=fallback-runner.js.map

package/dist/gateways/builtin-gateway.d.ts

@@ -14,4 +14,3 @@ export declare function registerProvider(name: string, factory: ProviderFactory)
 /** @internal Access the default singleton instance. */
 export declare function getDefaultBuiltInGateway(): BuiltInGateway;
 export {};
-//# sourceMappingURL=builtin-gateway.d.ts.map

package/dist/gateways/builtin-gateway.js

@@ -55,4 +55,3 @@ export function registerProvider(name, factory) {
 export function getDefaultBuiltInGateway() {
     return defaultInstance;
 }
-//# sourceMappingURL=builtin-gateway.js.map

package/dist/gateways/gateway-chain.d.ts

@@ -5,5 +5,8 @@ export declare class GatewayChain {
     register(gateway: ModelGateway): void;
     resolve(modelString: string): Promise<LanguageModel>;
     get size(): number;
+    listGateways(): Array<{
+        name: string;
+        canResolve: (model: string) => boolean;
+    }>;
 }
-//# sourceMappingURL=gateway-chain.d.ts.map

package/dist/gateways/gateway-chain.js

@@ -14,5 +14,10 @@ export class GatewayChain {
     get size() {
         return this.gateways.length;
     }
+    listGateways() {
+        return this.gateways.map(gw => ({
+            name: gw.name,
+            canResolve: (model) => gw.canResolve(model),
+        }));
+    }
 }
-//# sourceMappingURL=gateway-chain.js.map

package/dist/gateways/openai-compatible-gateway.d.ts

@@ -7,4 +7,3 @@ export declare class OpenAICompatibleGateway implements ModelGateway {
     canResolve(modelString: string): boolean;
     resolve(modelString: string): Promise<unknown>;
 }
-//# sourceMappingURL=openai-compatible-gateway.d.ts.map

package/dist/gateways/openai-compatible-gateway.js

@@ -23,4 +23,3 @@ export class OpenAICompatibleGateway {
         return sdk.chatModel(modelId);
     }
 }
-//# sourceMappingURL=openai-compatible-gateway.js.map

package/dist/harness.d.ts

@@ -41,4 +41,3 @@ export declare class HarnessAPIImpl implements HarnessAPI {
     getResources(): ResourceDeclaration[];
     getUnsubFns(): Array<() => void>;
 }
-//# sourceMappingURL=harness.d.ts.map

package/dist/harness.js

@@ -67,4 +67,3 @@ export class HarnessAPIImpl {
         return this.unsubFns;
     }
 }
-//# sourceMappingURL=harness.js.map

package/dist/hook-manager.d.ts

@@ -19,4 +19,3 @@ export declare class HookManager {
     private getSortedHooks;
     private bridge;
 }
-//# sourceMappingURL=hook-manager.d.ts.map

package/dist/hook-manager.js

@@ -89,4 +89,3 @@ export class HookManager {
         }
     }
 }
-//# sourceMappingURL=hook-manager.js.map

package/dist/index.d.ts

@@ -10,6 +10,7 @@ export { StorageReplayBackend } from './storage-replay-backend.js';
 export { HookManager, type HookManagerOptions } from './hook-manager.js';
 export { ToolRegistry, type AiSdkToolSchema, type ToolRegistryOptions } from './tool-registry.js';
 export { FilesystemSessionStorage } from './session-storage.js';
+export { SqliteSessionStorage } from './session-storage-sqlite.js';
 export { SessionPersistence } from './session-persistence.js';
 export { SessionManagerImpl } from './session-manager.js';
 export { createSubAgentTool } from './sub-agent.js';
@@ -31,4 +32,5 @@ export { TiktokenCounter } from './token-counter.js';
 export type { StreamEvent } from '@primo-ai/sdk';
 export { OpenAICompatibleGateway } from './gateways/openai-compatible-gateway.js';
 export { AgentForgeError, RecoverableError, FatalError, AuthError, ModelNotFoundError, ToolExecutionError, type AgentErrorOptions, } from './errors.js';
-//# sourceMappingURL=index.d.ts.map
+export { PermissionManager } from './pending-permission.js';
+export type { PendingPermission } from './pending-permission.js';

package/dist/index.js

@@ -11,6 +11,7 @@ export { StorageReplayBackend } from './storage-replay-backend.js';
 export { HookManager } from './hook-manager.js';
 export { ToolRegistry } from './tool-registry.js';
 export { FilesystemSessionStorage } from './session-storage.js';
+export { SqliteSessionStorage } from './session-storage-sqlite.js';
 export { SessionPersistence } from './session-persistence.js';
 export { SessionManagerImpl } from './session-manager.js';
 export { createSubAgentTool } from './sub-agent.js';
@@ -31,4 +32,4 @@ export { HarnessAPIImpl } from './harness.js';
 export { TiktokenCounter } from './token-counter.js';
 export { OpenAICompatibleGateway } from './gateways/openai-compatible-gateway.js';
 export { AgentForgeError, RecoverableError, FatalError, AuthError, ModelNotFoundError, ToolExecutionError, } from './errors.js';
-//# sourceMappingURL=index.js.map
+export { PermissionManager } from './pending-permission.js';

package/dist/llm-invoker.d.ts

@@ -17,18 +17,17 @@ export interface LLMInvokeInput {
 }
 export interface LLMInvokeResult {
     response: string;
-    tokenUsage: TokenUsage;
+    tokenUsage: TokenUsage | null;
 }
 export interface LLMStreamHandle {
     fullStream: AsyncIterable<unknown>;
-    usage: Promise<TokenUsage>;
+    usage: Promise<TokenUsage | null>;
     reasoning: Promise<string | undefined>;
 }
-export declare function extractTokenUsage(usage: unknown): TokenUsage;
+export declare function extractTokenUsage(usage: unknown): TokenUsage | null;
 export declare class LLMInvoker {
     private options;
     constructor(options: LLMInvokerOptions);
     invoke(input: LLMInvokeInput): Promise<LLMInvokeResult>;
     stream(input: LLMInvokeInput): LLMStreamHandle;
 }
-//# sourceMappingURL=llm-invoker.d.ts.map

package/dist/llm-invoker.js

@@ -3,14 +3,15 @@ import { SpanType } from '@primo-ai/sdk';
 import { streamWithRetry } from './retry.js';
 export function extractTokenUsage(usage) {
     const u = usage;
-    return {
-        input: typeof u?.inputTokens === 'number'
-            ? u.inputTokens
-            : u?.inputTokens?.total ?? 0,
-        output: typeof u?.outputTokens === 'number'
-            ? u.outputTokens
-            : u?.outputTokens?.total ?? 0,
-    };
+    if (!u)
+        return null;
+    const input = typeof u?.inputTokens === 'number'
+        ? u.inputTokens
+        : u?.inputTokens?.total ?? 0;
+    const output = typeof u?.outputTokens === 'number'
+        ? u.outputTokens
+        : u?.outputTokens?.total ?? 0;
+    return { input, output };
 }
 export class LLMInvoker {
     options;
@@ -112,7 +113,7 @@ export class LLMInvoker {
                 .catch((err) => {
                 endSpan();
                 this.options.eventBus?.emit('llm:usage_unavailable', { error: err instanceof Error ? err.message : String(err) });
-                return { input: 0, output: 0 };
+                return null;
             }),
             reasoning: Promise.resolve(result.reasoningText).catch((err) => {
                 this.options.eventBus?.emit('llm:reasoning_error', { error: err instanceof Error ? err.message : String(err) });
@@ -121,4 +122,3 @@ export class LLMInvoker {
         };
     }
 }
-//# sourceMappingURL=llm-invoker.js.map

package/dist/loop-orchestrator.d.ts

@@ -45,4 +45,3 @@ export declare class LoopOrchestrator {
     private afterIteration;
     private finalizeState;
 }
-//# sourceMappingURL=loop-orchestrator.d.ts.map

package/dist/loop-orchestrator.js

@@ -124,6 +124,8 @@ export class LoopOrchestrator {
                     yield event;
                     return;
                 }
+                if (event.type === 'error')
+                    throw event.error;
                 if (event.type === 'complete')
                     loopCtx = event.context;
                 yield event;
@@ -161,6 +163,14 @@ export class LoopOrchestrator {
                             yield event;
                             return;
                         }
+                        if (event.type === 'error') {
+                            if (event.recoverable) {
+                                this.eventBus?.emit('pipeline:stage_error', { stage: event.stage, error: event.error });
+                                loopBreak = true;
+                                break;
+                            }
+                            throw event.error;
+                        }
                         if (event.type === 'complete')
                             loopCtx = event.context;
                         yield event;
@@ -244,4 +254,3 @@ export class LoopOrchestrator {
         }
     }
 }
-//# sourceMappingURL=loop-orchestrator.js.map

package/dist/model-factory.d.ts

@@ -8,6 +8,9 @@ export declare class ModelFactory {
     resolve(modelString: string): Promise<LanguageModel>;
     registerGateway(gateway: ModelGateway): void;
     registerProvider(name: string, factory: ProviderFactory): void;
+    listGateways(): Array<{
+        name: string;
+        canResolve: (model: string) => boolean;
+    }>;
 }
 export {};
-//# sourceMappingURL=model-factory.d.ts.map

package/dist/model-factory.js

@@ -36,5 +36,7 @@ export class ModelFactory {
     registerProvider(name, factory) {
         this.providerGateway.addProvider(name, factory);
     }
+    listGateways() {
+        return this.chain.listGateways();
+    }
 }
-//# sourceMappingURL=model-factory.js.map

package/dist/model-profile.d.ts

@@ -14,4 +14,3 @@ export declare function matchProfile(model: string, profiles: ModelProfile[]): M
  * - toolOverrides.exclude removes matching tools; description overrides update them.
  */
 export declare function applyProfile(ctx: PipelineContext, profile: ModelProfile): PipelineContext;
-//# sourceMappingURL=model-profile.d.ts.map

package/dist/model-profile.js

@@ -54,4 +54,3 @@ export function applyProfile(ctx, profile) {
         },
     };
 }
-//# sourceMappingURL=model-profile.js.map

package/dist/model-resolver.d.ts

@@ -13,4 +13,3 @@ export { parseModel, type ParsedModel } from './parse-model.js';
 export declare function resolveModel(modelString: string): Promise<LanguageModel>;
 /** Create a gateway chain with custom gateways prepended before BuiltInGateway. */
 export declare function createChain(configs?: GatewayConfig[]): GatewayChain;
-//# sourceMappingURL=model-resolver.d.ts.map

package/dist/model-resolver.js

@@ -25,4 +25,3 @@ export function createChain(configs) {
     chain.register(getDefaultBuiltInGateway());
     return chain;
 }
-//# sourceMappingURL=model-resolver.js.map

package/dist/parse-model.d.ts

@@ -3,4 +3,3 @@ export interface ParsedModel {
     modelId: string;
 }
 export declare function parseModel(modelString: string): ParsedModel;
-//# sourceMappingURL=parse-model.d.ts.map

package/dist/parse-model.js

@@ -8,4 +8,3 @@ export function parseModel(modelString) {
         modelId: modelString.slice(idx + 1),
     };
 }
-//# sourceMappingURL=parse-model.js.map

package/dist/pending-permission.d.ts

@@ -0,0 +1,16 @@
+export interface PendingPermission {
+    permissionId: string;
+    sessionId: string;
+    toolName: string;
+    args: Record<string, unknown>;
+    reason: string;
+    createdAt: string;
+}
+export declare class PermissionManager {
+    private pending;
+    awaitDecision(permission: PendingPermission): Promise<boolean>;
+    resolve(permissionId: string, approved: boolean): void;
+    list(): PendingPermission[];
+    getBySession(sessionId: string): PendingPermission[];
+    get(permissionId: string): PendingPermission | undefined;
+}