@arnilo/prism 0.2.4 → 0.2.6

package/dist/contracts-core/agent.d.ts

@@ -0,0 +1,257 @@
+/** Contracts-core agent family (0.2.5 plan 025 Task 1 split).
+ * Moved verbatim from contracts-core.ts; public surface unchanged behind the barrel. */
+import type { AgentRunStateOptions, AgentSession } from "../contracts-run-state.js";
+import type { ContributionRegistries } from "../contributions.js";
+import type { InputAssemblyLayout, RunLedger, ToolDefinition, ToolEffectStore, ToolRegistry } from "../contracts-protocol.js";
+import type { MiddlewareRegistry } from "../middleware.js";
+import type { PermissionPolicy, TrustPolicy } from "../security.js";
+import type { SecretRedactor } from "../redaction.js";
+import type { ToolValidator } from "../tools.js";
+import type { AIProvider, ProviderRequestOptions, ProviderResolver } from "./provider.js";
+import type { AgentLoopOptions, AgentLoopStrategy } from "./loop.js";
+import type { CompactionOptions, RetryOptions } from "./compaction.js";
+import type { ContentBlock, ErrorInfo, JsonObject, Message, ModelConfig } from "./content.js";
+import type { ProviderRequestPolicy, SystemPromptConfig } from "./extensions.js";
+import type { Guardrails, RunLimits } from "./run-limits.js";
+import type { OwnershipScope } from "./persistence.js";
+import type { ResourceLoader } from "./resources.js";
+import type { SessionStore } from "./session.js";
+export interface AgentDefinition {
+    readonly name: string;
+    readonly description?: string;
+    /** Direct model config, or a model id resolved from `registries.models`. */
+    readonly model?: ModelConfig | string;
+    /** Tool names to activate from the active tool registry / `registries.tools`. */
+    readonly tools?: readonly string[];
+    /** Skill names resolved through `resolveActiveSkills()`; `toolNames` enforcement applies. */
+    readonly skills?: readonly string[];
+    /** Context provider names from `registries.contextProviders`. */
+    readonly context?: readonly string[];
+    readonly systemPrompt?: SystemPromptConfig;
+    readonly instructions?: string;
+    readonly loop?: AgentLoopStrategy | AgentLoopOptions;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+    /** Optional escape hatch. When present, overrides declarative resolution. */
+    create?(config?: AgentConfig): Promise<Agent> | Agent;
+}
+/** Input to {@link resolveAgentDefinition}. All fields are optional; the host
+ *  controls scope by which registries it passes. */
+export interface AgentDefinitionResolutionContext {
+    readonly registries?: ContributionRegistries;
+    readonly providerSource?: ProviderResolver;
+    readonly tools?: ToolRegistry | readonly ToolDefinition[];
+    readonly skillsRegistry?: SkillRegistry;
+    /** Migration-only: omitted `tools`/`skills` activate every in-scope tool/skill. Defaults to fail-closed. */
+    readonly activateAllCapabilities?: true;
+    readonly overrides?: Partial<AgentConfig>;
+}
+export interface AgentConfig {
+    readonly id?: string;
+    readonly name?: string;
+    readonly instructions?: string;
+    readonly model: ModelConfig;
+    readonly provider?: AIProvider;
+    readonly providerSource?: ProviderResolver;
+    readonly tools?: ToolRegistry | readonly ToolDefinition[];
+    readonly context?: readonly ContextProvider[];
+    readonly skills?: SkillRegistry | readonly Skill[];
+    /** Migration opt-in: activate every registry skill by default when run options do not narrow activation. */
+    readonly activateAllSkills?: true;
+    /** Progressive: catalog (name+description) unless loaded; eager: full instructions every turn. Default progressive. */
+    readonly skillsDisclosure?: import("../skill-disclosure.js").SkillsDisclosure;
+    /** Opt-in projection-only fold for aged large tool results in provider view; store untouched. */
+    readonly toolResultFold?: import("../tool-result-fold.js").ToolResultFoldOptions;
+    readonly inputBuilder?: InputBuilder;
+    readonly promptBuilder?: PromptBuilder;
+    readonly middleware?: MiddlewareRegistry;
+    readonly resourceLoader?: ResourceLoader;
+    readonly store?: SessionStore;
+    readonly permission?: PermissionPolicy;
+    /** Optional trust check for tool and resource targets. */
+    readonly trust?: TrustPolicy;
+    readonly providerOptions?: ProviderRequestOptions;
+    readonly providerRequestPolicies?: ProviderRequestPolicy | readonly ProviderRequestPolicy[];
+    readonly systemPrompt?: SystemPromptConfig;
+    readonly redactor?: SecretRedactor;
+    readonly runLedger?: RunLedger;
+    /** Optional durable recovery store. */
+    readonly effectStore?: ToolEffectStore;
+    readonly ownership?: OwnershipScope;
+    /** Host-verified identity default for sessions created from this agent. */
+    readonly identity?: import("../identity.js").AgentIdentity;
+    readonly idempotencyKey?: string;
+    readonly compaction?: false | CompactionOptions;
+    readonly retry?: false | RetryOptions;
+    /** Agent-wide ceilings; per-run limits may only narrow these values. */
+    readonly limits?: RunLimits;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+    readonly validator?: ToolValidator;
+    readonly instructionInjectors?: readonly InstructionInjector[];
+    readonly inputLayout?: InputAssemblyLayout;
+    readonly loop?: AgentLoopStrategy | AgentLoopOptions;
+    readonly guardrails?: Guardrails;
+    /** Opt-in durable interruption/checkpointing default for this agent. */
+    readonly runState?: AgentRunStateOptions;
+    /** Internal marker set by createSecureAgent(); makes security defaults immutable per run. */
+    readonly secure?: true;
+}
+/** Opt-in fail-closed composition over the normal explicit AgentConfig API. */
+export interface SecureAgentOptions extends Omit<AgentConfig, "tools" | "validator" | "redactor" | "permission" | "trust" | "ownership" | "identity" | "limits" | "runState" | "secure"> {
+    readonly id: string;
+    readonly tools: readonly ToolDefinition[];
+    readonly toolArgumentValidator: import("../tools.js").ToolArgumentValidator;
+    readonly redactor: SecretRedactor;
+    readonly permission: PermissionPolicy;
+    readonly trust: TrustPolicy;
+    readonly ownership: OwnershipScope;
+    /** Optional host-verified identity; when set must match `ownership`. */
+    readonly identity?: import("../identity.js").AgentIdentity;
+    readonly limits: RunLimits;
+    readonly definitionRevision: string;
+    readonly runState: Omit<AgentRunStateOptions, "definitionRevision" | "interruptBeforeTool">;
+}
+export interface Agent {
+    readonly config: AgentConfig;
+    createSession(config?: AgentSessionConfig): AgentSession;
+}
+export interface AgentSessionConfig {
+    readonly id?: string;
+    readonly agent?: Agent;
+    readonly store?: SessionStore;
+    readonly leafId?: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+export interface AgentSessionForkOptions {
+    readonly leafId?: string;
+}
+export interface AgentSessionCloneOptions {
+    readonly id?: string;
+    readonly leafId?: string;
+}
+export type SubscriberOverflowPolicy = "close" | "drop_oldest" | "drop_newest";
+export interface SubscribeOptions {
+    /** Maximum queued events for a subscriber that is not actively awaiting `next()`. Defaults to 1024. */
+    readonly maxQueuedEvents?: number;
+    /** What to do when `maxQueuedEvents` is reached. Defaults to `close`. */
+    readonly overflow?: SubscriberOverflowPolicy;
+}
+export interface CommandDefinition {
+    readonly name: string;
+    readonly description?: string;
+    readonly parameters?: JsonObject;
+    execute(args: JsonObject, context: CommandExecutionContext): Promise<CommandResult> | CommandResult;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+export interface CommandExecutionContext {
+    readonly sessionId?: string;
+    readonly runId?: string;
+    readonly signal?: AbortSignal;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+export interface CommandResult {
+    readonly name: string;
+    readonly content?: readonly ContentBlock[];
+    readonly value?: unknown;
+    readonly error?: ErrorInfo;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+export interface ContextBlock {
+    readonly id?: string;
+    readonly title?: string;
+    readonly content: string | readonly ContentBlock[];
+    readonly priority?: number;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+export interface ContextProvider {
+    readonly name: string;
+    resolve(context: ContextResolutionContext): Promise<readonly ContextBlock[]> | readonly ContextBlock[];
+}
+export interface ContextResolutionContext {
+    readonly sessionId?: string;
+    readonly runId?: string;
+    readonly messages: readonly Message[];
+    readonly metadata?: Readonly<Record<string, unknown>>;
+    readonly signal?: AbortSignal;
+}
+/** When an {@link InstructionInjector} contributes to the assembled provider input. */
+export type InstructionTiming = "first_turn" | "every_turn" | "on_input";
+/** Runtime turn scope handed to an {@link InstructionInjector}. Mirrors {@link LoopContext}
+ *  scope using already-redacted input/history so predicates cannot recover secrets. */
+export interface InstructionContext {
+    readonly sessionId: string;
+    readonly runId: string;
+    readonly turn: number;
+    readonly input: readonly Message[];
+    readonly history: readonly Message[];
+    readonly metadata: Readonly<Record<string, unknown>>;
+    readonly signal: AbortSignal;
+}
+/** Output of an {@link InstructionInjector}. Only `instructions` and `contextBlocks` are
+ *  honored; other fields grant nothing (no tools, skills, or permissions). */
+export interface InstructionContribution {
+    readonly instructions?: string;
+    readonly contextBlocks?: readonly ContextBlock[];
+    readonly when: InstructionTiming;
+    /** Used only when `when === "on_input"`; absent predicate means apply every turn. */
+    readonly predicate?: (ctx: InstructionContext) => boolean;
+}
+/** Additive instruction/context contribution that a package registers through
+ *  {@link ExtensionAPI.registerInstructionInjector} and the host selects on
+ *  {@link AgentConfig.instructionInjectors} / {@link RunOptions.instructionInjectors}.
+ *  Inert until selected; cannot grant privileges beyond text/context blocks. */
+export interface InstructionInjector {
+    readonly name: string;
+    readonly description?: string;
+    apply(ctx: InstructionContext): InstructionContribution;
+}
+export interface InputBuilder {
+    readonly name: string;
+    build(input: string | Message | readonly Message[], context?: InputBuildContext): Promise<readonly Message[]> | readonly Message[];
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+export interface InputBuildContext {
+    readonly inputLayout?: InputAssemblyLayout;
+    readonly sessionId?: string;
+    readonly runId?: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+    readonly signal?: AbortSignal;
+    readonly permission?: PermissionPolicy;
+    readonly trust?: TrustPolicy;
+}
+export interface PromptBuilder {
+    readonly name: string;
+    build(request: PromptBuildRequest): Promise<readonly Message[]> | readonly Message[];
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+export interface PromptBuildRequest {
+    readonly messages: readonly Message[];
+    readonly context?: readonly ContextBlock[];
+    readonly skills?: readonly Skill[];
+    readonly skillsDisclosure?: import("../skill-disclosure.js").SkillsDisclosure;
+    readonly loadedSkills?: import("../skill-disclosure.js").LoadedSkillSet;
+    /** Skills demoted to catalog-only by context budget this turn. */
+    readonly demotedSkillBodies?: readonly string[];
+    readonly tools?: readonly ToolDefinition[];
+    /** Model being prompted; lets builders adapt composition to declared capabilities
+     *  (e.g. the default builder omits the `Available tools:` text for tool-capable models). */
+    readonly model?: ModelConfig;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+    readonly signal?: AbortSignal;
+}
+export interface Skill {
+    readonly name: string;
+    readonly description?: string;
+    readonly instructions?: string;
+    readonly context?: readonly ContextProvider[];
+    readonly toolNames?: readonly string[];
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+export interface SkillRegistry {
+    register(skill: Skill): void;
+    get(name: string): Skill | undefined;
+    resolve(name: string): Skill;
+    list(): readonly Skill[];
+}
+/** Directory-name spelling for discovered contribution kinds. Maps to a
+ *  {@link ManifestContributionDeclaration} kind for non-skill kinds:
+ *  `context` → `contextProvider`, `instructions` → `systemPromptContribution`. */

package/dist/contracts-core/agent.js

@@ -0,0 +1,5 @@
+export {};
+/** Directory-name spelling for discovered contribution kinds. Maps to a
+ *  {@link ManifestContributionDeclaration} kind for non-skill kinds:
+ *  `context` → `contextProvider`, `instructions` → `systemPromptContribution`. */
+//# sourceMappingURL=agent.js.map

package/dist/contracts-core/compaction.d.ts

@@ -0,0 +1,72 @@
+/** Contracts-core compaction family (0.2.5 plan 025 Task 1 split).
+ * Moved verbatim from contracts-core.ts; public surface unchanged behind the barrel. */
+import type { ErrorInfo } from "./content.js";
+import type { SessionEntry } from "./session.js";
+export interface CompactionStrategy {
+    readonly name: string;
+    compact(context: CompactionContext): Promise<CompactionResult> | CompactionResult;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+export interface CompactionContext {
+    readonly sessionId: string;
+    readonly entries: readonly SessionEntry[];
+    readonly keepRecentEntries?: number;
+    readonly trigger?: "manual" | "auto" | string;
+    readonly secrets?: readonly (string | undefined)[];
+    readonly metadata?: Readonly<Record<string, unknown>>;
+    readonly signal?: AbortSignal;
+}
+export interface CompactionResult {
+    readonly summary: string;
+    readonly entries?: readonly SessionEntry[];
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+export interface CompactionOptions {
+    readonly strategy?: CompactionStrategy;
+    readonly thresholdEntries?: number;
+    readonly keepRecentEntries?: number;
+    readonly maxSummaryChars?: number;
+    readonly secrets?: readonly (string | undefined)[];
+    readonly metadata?: Readonly<Record<string, unknown>>;
+    readonly signal?: AbortSignal;
+}
+export interface CompactionMiddlewarePayload {
+    readonly context: CompactionContext;
+    readonly result: CompactionResult;
+}
+export interface CompactionEntryData {
+    readonly throughEntryId?: string;
+    readonly keepEntryIds?: readonly string[];
+    readonly strategy?: string;
+    readonly trigger?: "manual" | "auto" | string;
+}
+export interface RetryPolicy {
+    readonly name: string;
+    decide(context: RetryContext): Promise<RetryDecision> | RetryDecision;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+export interface RetryContext {
+    readonly sessionId: string;
+    readonly runId: string;
+    readonly attempt: number;
+    readonly error: ErrorInfo;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+    readonly signal?: AbortSignal;
+}
+export interface RetryDecision {
+    readonly retry: boolean;
+    readonly delayMs?: number;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+export interface RetryOptions {
+    readonly policy?: RetryPolicy;
+    readonly maxAttempts?: number;
+    readonly baseDelayMs?: number;
+    readonly maxDelayMs?: number;
+    readonly secrets?: readonly (string | undefined)[];
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+export interface RetryMiddlewarePayload {
+    readonly context: RetryContext;
+    readonly decision: RetryDecision;
+}

package/dist/contracts-core/compaction.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=compaction.js.map

package/dist/contracts-core/content.d.ts

@@ -0,0 +1,116 @@
+/** Contracts-core content family (0.2.5 plan 025 Task 1 split).
+ * Moved verbatim from contracts-core.ts; public surface unchanged behind the barrel. */
+import type { AudioContent, DocumentContent, FileContent } from "../content.js";
+import type { ModelCacheCapabilities } from "./provider.js";
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonObject | JsonValue[];
+export interface JsonObject {
+    readonly [key: string]: JsonValue;
+}
+export interface ErrorInfo {
+    readonly name?: string;
+    readonly message: string;
+    readonly code?: string | number;
+    /** Provider backpressure hint (e.g. from a `Retry-After` header); retry policies
+     *  honor it capped at their own `maxDelayMs`. */
+    readonly retryAfterMs?: number;
+    readonly cause?: unknown;
+}
+export type ContentBlock = TextContent | ImageContent | AudioContent | FileContent | DocumentContent | ThinkingContent | ToolCallDeltaContent | ToolCallContent | ToolResultContent;
+export interface TextContent {
+    readonly type: "text";
+    readonly text: string;
+}
+export interface ImageContent {
+    readonly type: "image";
+    readonly mimeType?: string;
+    readonly data?: string;
+    readonly url?: string;
+    readonly resourceUri?: string;
+    readonly name?: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+export interface ThinkingContent {
+    readonly type: "thinking";
+    readonly text: string;
+    readonly signature?: string;
+}
+export interface ToolCallDeltaContent {
+    readonly type: "tool_call_delta";
+    readonly index: number;
+    readonly id?: string;
+    readonly name?: string;
+    readonly argumentsText?: string;
+    /** Who executes the call. `"provider-hosted"` = the provider runs it server-side;
+     *  the host must NOT dispatch it or send a `tool_result`. Defaults to `"host"`. */
+    readonly authority?: ToolCallAuthority;
+}
+export type ToolCallAuthority = "host" | "provider-hosted";
+export interface ToolCallContent {
+    readonly type: "tool_call";
+    readonly id: string;
+    readonly name: string;
+    readonly arguments: JsonObject;
+    /** Set when streamed arguments failed JSON parse; dispatch blocks without execute(). */
+    readonly argumentsError?: ErrorInfo;
+    /** Who executes the call. `"provider-hosted"` = the provider already ran it
+     *  server-side; the host must NOT dispatch it or append a `tool_result`. The
+     *  assistant response text already incorporates the call's effect. */
+    readonly authority?: ToolCallAuthority;
+}
+export interface ToolResultContent {
+    readonly type: "tool_result";
+    readonly toolCallId: string;
+    readonly name: string;
+    readonly result?: unknown;
+    readonly error?: ErrorInfo;
+}
+export interface Message {
+    readonly id?: string;
+    readonly role: "system" | "user" | "assistant" | "tool";
+    readonly content: readonly ContentBlock[];
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+export interface ModelConfig {
+    readonly provider: string;
+    readonly model: string;
+    readonly displayName?: string;
+    readonly capabilities?: ModelCapabilities;
+    readonly limits?: ModelLimits;
+    readonly cost?: ModelCost;
+    readonly cache?: ModelCacheCapabilities;
+    readonly compat?: JsonObject;
+    readonly parameters?: Readonly<Record<string, unknown>>;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+export interface ModelCapabilities {
+    /** Known values include `text`, `image`, `audio`, `file`, and `document`. */
+    readonly input?: readonly string[];
+    readonly output?: readonly string[];
+    readonly reasoning?: boolean;
+    readonly tools?: boolean;
+    readonly streaming?: boolean;
+    /** Native JSON-schema structured output support for this model. */
+    readonly structuredOutput?: boolean | "json_schema";
+}
+export interface ModelLimits {
+    readonly contextWindow?: number;
+    readonly maxOutputTokens?: number;
+}
+export interface ModelCost {
+    readonly input?: number;
+    readonly output?: number;
+    readonly cacheRead?: number;
+    readonly cacheWrite?: number;
+    readonly currency?: string;
+    readonly unit?: string;
+}
+export interface Usage {
+    readonly inputTokens?: number;
+    readonly outputTokens?: number;
+    readonly totalTokens?: number;
+    readonly cacheReadTokens?: number;
+    readonly cacheWriteTokens?: number;
+    readonly cost?: number;
+    readonly currency?: string;
+}

package/dist/contracts-core/content.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=content.js.map

package/dist/contracts-core/extensions.d.ts

@@ -0,0 +1,163 @@
+/** Contracts-core extensions family (0.2.5 plan 025 Task 1 split).
+ * Moved verbatim from contracts-core.ts; public surface unchanged behind the barrel. */
+import type { ContributionRegistries } from "../contributions.js";
+import type { ManifestContributionDeclaration } from "../manifests.js";
+import type { Middleware, MiddlewareHookName, MiddlewareRegistry } from "../middleware.js";
+import type { ToolDefinition } from "../contracts-protocol.js";
+import type { AIProvider, ProviderRequest } from "./provider.js";
+import type { AgentDefinition, CommandDefinition, ContextProvider, InputBuilder, InstructionInjector, PromptBuilder, Skill } from "./agent.js";
+import type { CompactionStrategy, RetryPolicy } from "./compaction.js";
+import type { Credential, CredentialResolver, ResourceLoader, SettingsProvider } from "./resources.js";
+import type { ErrorInfo, ModelConfig } from "./content.js";
+import type { StoreFactory } from "./persistence.js";
+export type ContributionFileKind = "skill" | "tool" | "context" | "instructions";
+/** Inert envelope emitted by the host/CLI discovery scanner. Carries the
+ *  realized {@link Skill} for skill kinds and a manifest-referenced
+ *  {@link ManifestContributionDeclaration} for other kinds; the host owns
+ *  any executable behavior. Contains no code, no credential. */
+export interface DiscoveredContribution {
+    readonly kind: ContributionFileKind;
+    readonly name: string;
+    readonly origin: "global" | "workspace";
+    readonly path: string;
+    /** Present when `kind === "skill"`. */
+    readonly skill?: Skill;
+    /** Present for non-skill kinds. */
+    readonly declaration?: ManifestContributionDeclaration;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+export type ExtensionLifecycleEventName = "resource_discovery" | "session_start" | "session_shutdown" | "before_agent_start" | "turn" | "context" | "provider_request" | "tool_call" | "tool_result" | "compaction" | "retry";
+export interface ExtensionEvent {
+    readonly type: ExtensionLifecycleEventName | "extension_error" | string;
+    readonly payload?: unknown;
+    readonly extension?: string;
+    readonly error?: ErrorInfo;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+export interface Extension {
+    readonly name: string;
+    setup(api: ExtensionAPI): void | Promise<void>;
+    /** Host-attested signature/digest for `ExtensionLoadPolicy.verifySignature`. */
+    readonly signature?: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+export interface ProviderPackage {
+    readonly name: string;
+    readonly version?: string;
+    readonly description?: string;
+    readonly docs?: ProviderPackageDocs;
+    setup(api: ProviderPackageAPI): void | Promise<void>;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+export interface ProviderPackageDocs {
+    readonly description?: string;
+    readonly links?: readonly string[];
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+export interface ProviderPackageAPI extends ExtensionAPI {
+}
+export type AuthMethod = ApiKeyAuthMethod | OAuthAuthMethod | CustomAuthMethod;
+export interface ApiKeyAuthMethod {
+    readonly kind: "api_key";
+    readonly provider: string;
+    readonly name?: string;
+    readonly credentialName?: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+export interface OAuthAuthMethod {
+    readonly kind: "oauth";
+    readonly provider: string;
+    readonly name?: string;
+    readonly oauth?: OAuthProvider;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+export interface OAuthLoginCallbacks {
+    onAuth?(url: string): void | Promise<void>;
+    onDeviceCode?(code: {
+        readonly userCode: string;
+        readonly verificationUri: string;
+        readonly expiresAt?: string;
+    }): void | Promise<void>;
+    onPrompt?(message: string): string | undefined | Promise<string | undefined>;
+    onSelect?(prompt: {
+        readonly message: string;
+        readonly choices: readonly string[];
+    }): string | undefined | Promise<string | undefined>;
+    /** Aborts OAuth login flows and device-code polling when signaled. */
+    readonly signal?: AbortSignal;
+}
+export interface OAuthCredentials {
+    readonly access?: string;
+    readonly refresh?: string;
+    readonly expires?: string | number;
+    readonly accountId?: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+export interface OAuthProvider {
+    readonly id: string;
+    login(callbacks?: OAuthLoginCallbacks): Promise<OAuthCredentials> | OAuthCredentials;
+    refresh?(credentials: OAuthCredentials): Promise<OAuthCredentials> | OAuthCredentials;
+    /** Best-effort upstream revocation; the store delete is what fails closed locally. */
+    revoke?(credentials: OAuthCredentials): Promise<void> | void;
+    getCredential?(credentials: OAuthCredentials): Promise<Credential | undefined> | Credential | undefined;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+export interface CustomAuthMethod {
+    readonly kind: "custom" | string;
+    readonly provider: string;
+    readonly name?: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+export interface ProviderRequestPolicy {
+    readonly name: string;
+    apply(context: ProviderRequestPolicyContext): Promise<ProviderRequest | ProviderRequestPolicyResult> | ProviderRequest | ProviderRequestPolicyResult;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+export interface ProviderRequestPolicyContext {
+    readonly request: ProviderRequest;
+    readonly sessionId?: string;
+    readonly runId?: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+    readonly signal?: AbortSignal;
+}
+export interface ProviderRequestPolicyResult {
+    readonly request: ProviderRequest;
+    readonly secrets?: readonly (string | undefined)[];
+}
+export type SystemPromptMode = "append" | "prepend" | "replace" | "disable";
+export type SystemPromptSource = "package" | "app" | "user" | "run" | string;
+export interface SystemPromptContribution {
+    readonly id: string;
+    readonly source?: SystemPromptSource;
+    readonly mode?: SystemPromptMode;
+    readonly text: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+export type SystemPromptConfig = false | SystemPromptContribution | readonly SystemPromptContribution[];
+export interface ExtensionAPI {
+    readonly registries: ContributionRegistries;
+    readonly middleware: MiddlewareRegistry;
+    on(type: ExtensionLifecycleEventName | string, handler: (event: ExtensionEvent) => void | Promise<void>): () => void;
+    emit(event: ExtensionEvent): Promise<void>;
+    use<T>(hook: MiddlewareHookName | string, middleware: Middleware<T>): () => void;
+    registerProvider(provider: AIProvider): void;
+    registerModel(model: ModelConfig): void;
+    registerTool(tool: ToolDefinition): void;
+    registerContextProvider(provider: ContextProvider): void;
+    registerSkill(skill: Skill): void;
+    registerCommand(command: CommandDefinition): void;
+    registerAgent(agent: AgentDefinition): void;
+    registerInputBuilder(builder: InputBuilder): void;
+    registerPromptBuilder(builder: PromptBuilder): void;
+    registerCompactionStrategy(strategy: CompactionStrategy): void;
+    registerRetryPolicy(policy: RetryPolicy): void;
+    registerStoreFactory(factory: StoreFactory): void;
+    registerResourceLoader(key: string, loader: ResourceLoader): void;
+    registerSettingsProvider(key: string, provider: SettingsProvider): void;
+    registerCredentialResolver(key: string, resolver: CredentialResolver): void;
+    registerProviderPackage(providerPackage: ProviderPackage): void;
+    registerAuthMethod(method: AuthMethod): void;
+    registerProviderRequestPolicy(policy: ProviderRequestPolicy): void;
+    registerSystemPromptContribution(contribution: SystemPromptContribution): void;
+    registerInstructionInjector(injector: InstructionInjector): void;
+}

package/dist/contracts-core/extensions.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=extensions.js.map