@corbat-tech/coco 2.39.0 → 2.41.0

package/dist/{profiles-BcyL-gQ9.d.ts → profiles-GRoVNorK.d.ts}

@@ -1,5 +1,5 @@
-import { T as ToolRegistry } from './registry-CEpl9Jq0.js';
-import { b as RetrievedSource, K as KnowledgeRetriever } from './rag-BakFRE-u.js';
+import { R as RuntimeRequestContext, T as ToolRegistry } from './context-BLPsKYxc.js';
+import { R as RetrievedSource, K as KnowledgeRetriever } from './rag-B2oGudNb.js';
 
 interface SupportDraftInput {
     conversationId: string;
@@ -55,6 +55,7 @@ type SalesLeadSummaryHandler = (input: SalesLeadSummaryInput) => Promise<SalesLe
 type InternalOpsDraftHandler = (input: InternalOpsDraftInput) => Promise<InternalOpsDraftOutput>;
 interface SupportRagToolRegistryOptions {
     retriever?: KnowledgeRetriever;
+    runtimeContext?: RuntimeRequestContext;
     supportDraft?: SupportDraftHandler;
     humanEscalation?: HumanEscalationHandler;
 }
@@ -71,6 +72,8 @@ declare function createCustomerSupportToolRegistry(source?: ToolRegistry): ToolR
 declare function createSupportRagToolRegistry(options?: SupportRagToolRegistryOptions): ToolRegistry;
 declare function createSalesIntakeToolRegistry(options?: SalesIntakeToolRegistryOptions): ToolRegistry;
 declare function createInternalOpsToolRegistry(options?: InternalOpsToolRegistryOptions): ToolRegistry;
-declare function createRagToolRegistry(retriever?: KnowledgeRetriever): ToolRegistry;
+declare function createRagToolRegistry(retriever?: KnowledgeRetriever, options?: {
+    runtimeContext?: RuntimeRequestContext;
+}): ToolRegistry;
 
-export { type HumanEscalationHandler as H, type InternalOpsDraftHandler as I, type SupportDraftHandler as S, type HumanEscalationInput as a, type HumanEscalationOutput as b, type SupportDraftInput as c, type SupportDraftOutput as d, type SupportRagToolRegistryOptions as e, createCodingToolRegistry as f, createCustomerSupportToolRegistry as g, createNoToolRegistry as h, createPublicWebToolRegistry as i, createRagToolRegistry as j, createSupportRagToolRegistry as k, type InternalOpsDraftInput as l, type InternalOpsDraftOutput as m, type InternalOpsToolRegistryOptions as n, type SalesIntakeToolRegistryOptions as o, type SalesLeadSummaryHandler as p, type SalesLeadSummaryInput as q, type SalesLeadSummaryOutput as r, createInternalOpsToolRegistry as s, createSalesIntakeToolRegistry as t };
+export { type HumanEscalationHandler as H, type InternalOpsDraftHandler as I, type SupportDraftHandler as S, type SalesLeadSummaryHandler as a, type HumanEscalationInput as b, type HumanEscalationOutput as c, type SupportDraftInput as d, type SupportDraftOutput as e, type SupportRagToolRegistryOptions as f, createCodingToolRegistry as g, createCustomerSupportToolRegistry as h, createNoToolRegistry as i, createPublicWebToolRegistry as j, createRagToolRegistry as k, createSupportRagToolRegistry as l, type InternalOpsDraftInput as m, type InternalOpsDraftOutput as n, type InternalOpsToolRegistryOptions as o, type SalesIntakeToolRegistryOptions as p, type SalesLeadSummaryInput as q, type SalesLeadSummaryOutput as r, createInternalOpsToolRegistry as s, createSalesIntakeToolRegistry as t };

package/dist/rag-B2oGudNb.d.ts

@@ -0,0 +1,178 @@
+import { R as RuntimeRequestContext, D as DataBoundary } from './context-BLPsKYxc.js';
+
+interface RetrievedSource {
+    id: string;
+    title: string;
+    content: string;
+    url?: string;
+    score: number;
+    metadata?: Record<string, unknown>;
+}
+interface RagDocument {
+    id: string;
+    title: string;
+    content: string;
+    url?: string;
+    tenantId?: string;
+    sourceId?: string;
+    acl?: DocumentAcl;
+    classification?: "public" | "internal" | "confidential" | "restricted";
+    version?: string;
+    updatedAt?: string;
+    deletedAt?: string;
+    metadata?: Record<string, unknown>;
+}
+interface RagChunk {
+    id: string;
+    documentId: string;
+    title: string;
+    content: string;
+    url?: string;
+    tenantId?: string;
+    sourceId?: string;
+    acl?: DocumentAcl;
+    classification?: "public" | "internal" | "confidential" | "restricted";
+    version?: string;
+    updatedAt?: string;
+    deletedAt?: string;
+    metadata?: Record<string, unknown>;
+}
+interface DocumentAcl {
+    public?: boolean;
+    userIds?: string[];
+    roles?: string[];
+    groups?: string[];
+}
+interface Citation {
+    sourceId: string;
+    title: string;
+    url?: string;
+    score?: number;
+}
+interface RetrievalOptions {
+    limit?: number;
+    minScore?: number;
+    tenantId?: string;
+    userId?: string;
+    roles?: string[];
+    groups?: string[];
+    runtimeContext?: RuntimeRequestContext;
+    dataBoundary?: DataBoundary;
+    documentAccessPolicy?: DocumentAccessPolicy;
+}
+interface DocumentAccessPolicy {
+    canAccess(input: {
+        document: RagDocument | RagChunk | InMemoryKnowledgeDocument;
+        options: RetrievalOptions;
+    }): boolean;
+}
+interface DocumentLoader {
+    load(): Promise<RagDocument[]>;
+}
+interface Chunker {
+    chunk(document: RagDocument): Promise<RagChunk[]>;
+}
+interface EmbeddingProvider {
+    embed(texts: string[]): Promise<number[][]>;
+}
+interface VectorStore {
+    upsert(chunks: Array<RagChunk & {
+        embedding: number[];
+    }>): Promise<void>;
+    search(embedding: number[], options?: RetrievalOptions): Promise<RetrievedSource[]>;
+}
+interface Reranker {
+    rerank(query: string, sources: RetrievedSource[]): Promise<RetrievedSource[]>;
+}
+interface KnowledgeRetriever {
+    search(query: string, options?: RetrievalOptions): Promise<RetrievedSource[]>;
+}
+interface RagPipelineOptions {
+    loader?: DocumentLoader;
+    chunker?: Chunker;
+    embeddingProvider?: EmbeddingProvider;
+    vectorStore?: VectorStore;
+    retriever?: KnowledgeRetriever;
+    reranker?: Reranker;
+    runtimeContext?: RuntimeRequestContext;
+}
+interface RagPipeline {
+    ingest(): Promise<{
+        documents: number;
+        chunks: number;
+    }>;
+    retrieve(query: string, options?: RetrievalOptions): Promise<RetrievedSource[]>;
+}
+interface InMemoryKnowledgeDocument {
+    id: string;
+    title: string;
+    content: string;
+    url?: string;
+    tenantId?: string;
+    acl?: DocumentAcl;
+    deletedAt?: string;
+    metadata?: Record<string, unknown>;
+}
+interface RagIngestionJob {
+    id: string;
+    status: "pending" | "running" | "completed" | "failed";
+    startedAt?: string;
+    completedAt?: string;
+    result?: {
+        documents: number;
+        chunks: number;
+    };
+    error?: string;
+    run(): Promise<RagIngestionJob>;
+}
+interface CitationVerificationResult {
+    valid: boolean;
+    unsupportedCitations: Citation[];
+    missingSourceIds: string[];
+}
+interface GroundednessEvaluation {
+    grounded: boolean;
+    score: number;
+    blocked: boolean;
+    reasons: string[];
+}
+declare class InMemoryKnowledgeRetriever implements KnowledgeRetriever {
+    private readonly documents;
+    constructor(documents: InMemoryKnowledgeDocument[]);
+    search(query: string, options?: RetrievalOptions): Promise<RetrievedSource[]>;
+}
+declare class SimpleTextChunker implements Chunker {
+    private readonly options;
+    constructor(options?: {
+        maxChars?: number;
+        overlapChars?: number;
+    });
+    chunk(document: RagDocument): Promise<RagChunk[]>;
+}
+declare class InMemoryVectorStore implements VectorStore {
+    private chunks;
+    upsert(chunks: Array<RagChunk & {
+        embedding: number[];
+    }>): Promise<void>;
+    search(embedding: number[], options?: RetrievalOptions): Promise<RetrievedSource[]>;
+}
+declare function createDocumentAccessPolicy(input: {
+    tenantId?: string;
+    userId?: string;
+    roles?: string[];
+    groups?: string[];
+    requireAcl?: boolean;
+}): DocumentAccessPolicy;
+declare function createRagIngestionJob(id: string, pipeline: RagPipeline): RagIngestionJob;
+declare function verifyCitations(citations: Citation[], sources: RetrievedSource[]): CitationVerificationResult;
+declare function evaluateGroundedness(answer: string, sources: RetrievedSource[]): GroundednessEvaluation;
+declare function createInMemoryKnowledgeRetriever(documents: InMemoryKnowledgeDocument[]): KnowledgeRetriever;
+declare function createSimpleTextChunker(options?: {
+    maxChars?: number;
+    overlapChars?: number;
+}): Chunker;
+declare function createInMemoryVectorStore(): VectorStore;
+declare function createRagPipeline(options: RagPipelineOptions): RagPipeline;
+declare function formatRetrievedSourcesForPrompt(sources: RetrievedSource[]): string;
+
+export { type Chunker as C, type DocumentAccessPolicy as D, type EmbeddingProvider as E, type GroundednessEvaluation as G, type InMemoryKnowledgeDocument as I, type KnowledgeRetriever as K, type RetrievedSource as R, SimpleTextChunker as S, type VectorStore as V, type Citation as a, type CitationVerificationResult as b, type DocumentAcl as c, type DocumentLoader as d, InMemoryKnowledgeRetriever as e, InMemoryVectorStore as f, type RagChunk as g, type RagDocument as h, type RagIngestionJob as i, type RagPipeline as j, type RagPipelineOptions as k, type Reranker as l, type RetrievalOptions as m, createDocumentAccessPolicy as n, createInMemoryKnowledgeRetriever as o, createInMemoryVectorStore as p, createRagIngestionJob as q, createRagPipeline as r, createSimpleTextChunker as s, evaluateGroundedness as t, formatRetrievedSourcesForPrompt as u, verifyCitations as v };

package/dist/runtime/index.d.ts

@@ -1,11 +1,61 @@
-import { R as EventLog, a1 as RuntimeEventType, a0 as RuntimeEvent, a5 as RuntimeSessionStore, a4 as RuntimeSessionCreateOptions, a3 as RuntimeSession } from '../agent-runtime-DJY9FzL_.js';
-export { A as AGENT_MODES, d as AgentArtifact, e as AgentArtifactKind, f as AgentBudget, g as AgentCapability, h as AgentCard, i as AgentDefinition, j as AgentGateDefinition, k as AgentGateKind, l as AgentGraphDefinition, m as AgentGraphEdge, n as AgentGraphEngine, o as AgentGraphEngineOptions, p as AgentGraphNode, q as AgentGraphNodeExecution, r as AgentGraphNodeExecutor, s as AgentGraphRunInput, t as AgentGraphRunResult, u as AgentGraphRunStatus, v as AgentGraphValidationIssue, w as AgentGraphValidationResult, x as AgentGuardrailPolicy, y as AgentHandoff, z as AgentMessage, B as AgentMessageRole, D as AgentModeDefinition, E as AgentModeId, F as AgentRole, G as AgentRunResult, H as AgentRunStatus, I as AgentRuntime, J as AgentRuntimeOptions, K as AgentRuntimeSnapshot, $ as AgentTask, N as AgentToolPolicyDecision, O as AgentTraceContext, Q as DEFAULT_WORKFLOWS, T as FileSharedWorkspaceStore, U as InMemorySharedWorkspaceStore, V as LegacyAgentRoleMapping, W as PermissionDecision, X as PermissionPolicy, Y as ProviderRegistry, Z as ProviderRuntimeSelection, _ as ReasoningEffort, a2 as RuntimeMode, a6 as RuntimeToolExecutionInput, a7 as RuntimeToolExecutionResult, a8 as RuntimeTurnContext, a9 as RuntimeTurnInput, aa as RuntimeTurnResult, ab as RuntimeTurnRunner, ac as RuntimeTurnStreamEvent, ad as SharedWorkspaceProvenance, ae as SharedWorkspaceRecord, af as SharedWorkspaceRecordKind, ag as SharedWorkspaceState, ah as SharedWorkspaceStateSnapshot, ai as SharedWorkspaceStore, aj as SharedWorkspaceWriteInput, ak as ToolRiskLevel, al as ToolRiskManifest, am as ToolRiskManifestEntry, an as WorkflowCatalog, ao as WorkflowDefinition, ap as WorkflowEngine, aq as WorkflowHandler, ar as WorkflowPlan, as as WorkflowRegistry, at as WorkflowRetryPolicy, au as WorkflowRisk, av as WorkflowRunContext, aw as WorkflowRunInput, ax as WorkflowRunResult, ay as WorkflowRunStatus, az as WorkflowStepDefinition, aA as createAgentArtifact, aB as createAgentGraphEngine, aC as createAgentRuntime, aD as createAgentTraceContext, aF as createProviderRegistry, aG as createSummaryArtifact, aH as createWorkflowCatalog, aI as createWorkflowEngine, aJ as createWorkflowRegistry, aK as evaluateAgentToolPolicy, aL as getAgentMode, aM as isAgentMode, aN as listAgentModes, aO as listLegacyAgentRoleMappings, aP as mapLegacyAgentRole, aQ as normalizeAgentRunResult, aR as validateAgentCapabilities, aS as validateAgentGraph, aT as workflowToAgentGraph } from '../agent-runtime-DJY9FzL_.js';
-export { A as AgentRunner, a as AgentRunnerExecutionContext, b as AgentRunnerExecutionInput, c as AgentRunnerExecutor, d as AgentRunnerOptions, e as AgentRunnerRawResult, f as AgentSurface, D as DefaultPermissionPolicy, g as DefaultRuntimeTurnRunner, E as ExtensionRisk, F as FileEventLog, h as FileRuntimeSessionStore, I as InMemoryEventLog, i as InMemoryRuntimeSessionStore, M as McpToolPolicy, R as RecipeManifest, j as RecipeStep, k as RuntimeHttpServerOptions, S as SkillManifest, T as ToolCallingRuntimeTurnRunner, l as ToolCallingRuntimeTurnRunnerOptions, m as createAgentRunner, n as createDefaultRuntimeTurnRunner, o as createEventLog, p as createFileEventLog, q as createFileRuntimeSessionStore, r as createMcpToolPolicy, s as createPermissionPolicy, t as createRuntimeHttpServer, u as createRuntimeSessionStore, v as createToolCallingRuntimeTurnRunner } from '../extension-manifests-CAQQILhE.js';
-export { A as AgentActionMode, a as AgentBlueprint, b as AgentDeploymentSurface, c as AgentMaturity, d as AgentPreset, e as AgentRuntimeFactoryOptions, f as ApprovalPolicy, B as BlueprintAgent, G as GuardrailConfig, g as GuardrailFinding, h as GuardrailResult, i as GuardrailSeverity, j as GuardrailStage, M as MemoryConfig, O as ObservabilityConfig, S as SecretRedactionConfig, T as TopicBoundaryConfig, k as createAgentFromBlueprint, l as createBaseBlueprint, m as createSafeToolRegistry, n as defaultPublicGuardrails, o as mapActionModeToRuntimeMode, r as redactSecrets, p as runGuardrails, v as validateStructuredOutput } from '../blueprints-DYgm3K65.js';
-export { I as InMemoryKnowledgeDocument, a as InMemoryKnowledgeRetriever, K as KnowledgeRetriever, R as RetrievalOptions, b as RetrievedSource, c as createInMemoryKnowledgeRetriever, f as formatRetrievedSourcesForPrompt } from '../rag-BakFRE-u.js';
-import '../registry-CEpl9Jq0.js';
+import { A as AgentRuntime } from '../agent-runtime-BJeNjVuk.js';
+export { P as ProviderRegistry, R as RuntimeRetentionCleanupOptions, a as RuntimeRetentionCleanupResult, c as createAgentRuntime, b as createProviderRegistry } from '../agent-runtime-BJeNjVuk.js';
+import { c as RuntimeTurnRunner, f as RuntimeTurnInput, aD as RuntimeTurnContext, g as RuntimeTurnResult, E as EventLog, ax as RuntimeEventType, aw as RuntimeEvent, l as PermissionPolicy, r as RuntimeMode, bt as ToolDefinition, ap as PermissionDecision, ai as AsyncEventLog, ay as RuntimeHostMode, aj as AsyncRuntimeSessionStore, n as RuntimeSessionCreateOptions, e as RuntimeSession, k as RuntimeSessionStore, T as ToolRegistry, d as RuntimePolicy, q as RuntimeToolExecutionResult } from '../context-BLPsKYxc.js';
+export { w as AGENT_MODES, x as AgentArtifact, y as AgentArtifactKind, z as AgentBudget, B as AgentCapability, F as AgentCard, G as AgentDefinition, H as AgentDefinitionRegistry, I as AgentGateDefinition, J as AgentGateKind, K as AgentGraphDefinition, N as AgentGraphEdge, O as AgentGraphEngine, Q as AgentGraphEngineOptions, U as AgentGraphNode, V as AgentGraphNodeExecution, X as AgentGraphNodeExecutor, Y as AgentGraphRunInput, Z as AgentGraphRunResult, _ as AgentGraphRunStatus, $ as AgentGraphValidationIssue, a0 as AgentGraphValidationResult, a1 as AgentGuardrailPolicy, a2 as AgentHandoff, a3 as AgentMessage, a4 as AgentMessageRole, a5 as AgentModeDefinition, a6 as AgentModeId, a7 as AgentRole, a8 as AgentRunResult, a9 as AgentRunStatus, aa as AgentRunner, ab as AgentRunnerExecutionContext, ac as AgentRunnerExecutionInput, ad as AgentRunnerExecutor, ae as AgentRunnerOptions, af as AgentRunnerRawResult, A as AgentRuntimeOptions, m as AgentRuntimeSnapshot, av as AgentTask, ag as AgentToolPolicyDecision, ah as AgentTraceContext, ak as CostBudget, al as DEFAULT_WORKFLOWS, D as DataBoundary, am as FileSharedWorkspaceStore, an as InMemorySharedWorkspaceStore, ao as LegacyAgentRoleMapping, aq as ProviderRuntimeSelection, ar as ReasoningEffort, as as RetentionPolicy, at as RuntimeAgentNodeExecutor, au as RuntimeAgentNodeExecutorOptions, az as RuntimePolicyViolation, aA as RuntimePolicyViolationCode, R as RuntimeRequestContext, aB as RuntimeSurface, aC as RuntimeTenantBoundary, p as RuntimeToolExecutionInput, a as RuntimeTurnStreamEvent, aE as SharedWorkspaceProvenance, aF as SharedWorkspaceRecord, aG as SharedWorkspaceRecordKind, aH as SharedWorkspaceState, aI as SharedWorkspaceStateSnapshot, aJ as SharedWorkspaceStore, aK as SharedWorkspaceWriteInput, aL as TenantContext, aM as ToolRiskLevel, aN as ToolRiskManifest, aO as ToolRiskManifestEntry, aP as UserContext, aQ as WorkflowCatalog, aR as WorkflowDefinition, W as WorkflowEngine, aS as WorkflowHandler, aT as WorkflowPlan, aU as WorkflowRegistry, aV as WorkflowRetryPolicy, aW as WorkflowRisk, aX as WorkflowRunContext, aY as WorkflowRunInput, aZ as WorkflowRunResult, a_ as WorkflowRunStatus, a$ as WorkflowStepDefinition, b0 as assertRuntimeTenantBoundary, b1 as assertRuntimeTurnWithinPolicy, b2 as createAgentArtifact, b3 as createAgentDefinitionRegistry, b4 as createAgentGraphEngine, b5 as createAgentRunner, b6 as createAgentTraceContext, o as createRetentionCutoffs, b8 as createRuntimeAgentNodeExecutor, b9 as createRuntimeRequestContext, ba as createRuntimeTenantBoundary, bb as createSummaryArtifact, bd as createWorkflowCatalog, be as createWorkflowEngine, bf as createWorkflowRegistry, bg as dryRunAgentGraphNodeExecutor, bh as evaluateAgentToolPolicy, bi as getAgentMode, bj as isAgentMode, bk as listAgentModes, bl as listLegacyAgentRoleMappings, bm as mapLegacyAgentRole, bn as mergeRuntimePolicy, bo as normalizeAgentRunResult, bp as runtimeContextToMetadata, bq as validateAgentCapabilities, br as validateAgentGraph, bs as workflowToAgentGraph } from '../context-BLPsKYxc.js';
+import { Server } from 'node:http';
+export { a as AgentActionMode, b as AgentBlueprint, c as AgentDeploymentSurface, d as AgentMaturity, A as AgentPreset, e as AgentRuntimeFactoryOptions, f as ApprovalPolicy, B as BlueprintAgent, G as GuardrailAction, g as GuardrailConfig, h as GuardrailFinding, i as GuardrailPipelineResult, j as GuardrailPipelineStep, k as GuardrailResult, l as GuardrailSeverity, m as GuardrailStage, M as MemoryConfig, O as ObservabilityConfig, P as PolicyAsCodeProvider, S as SecretRedactionConfig, T as TopicBoundaryConfig, n as createAgentFromBlueprint, o as createBaseBlueprint, p as createSafeToolRegistry, q as defaultPublicGuardrails, r as mapActionModeToRuntimeMode, s as redactSecrets, t as runGuardrailPipeline, u as runGuardrails, v as validateStructuredOutput } from '../blueprints-Dw5-uWU9.js';
+export { C as Chunker, a as Citation, b as CitationVerificationResult, D as DocumentAccessPolicy, c as DocumentAcl, d as DocumentLoader, E as EmbeddingProvider, G as GroundednessEvaluation, I as InMemoryKnowledgeDocument, e as InMemoryKnowledgeRetriever, f as InMemoryVectorStore, K as KnowledgeRetriever, g as RagChunk, h as RagDocument, i as RagIngestionJob, j as RagPipeline, k as RagPipelineOptions, l as Reranker, m as RetrievalOptions, R as RetrievedSource, S as SimpleTextChunker, V as VectorStore, n as createDocumentAccessPolicy, o as createInMemoryKnowledgeRetriever, p as createInMemoryVectorStore, q as createRagIngestionJob, r as createRagPipeline, s as createSimpleTextChunker, t as evaluateGroundedness, u as formatRetrievedSourcesForPrompt, v as verifyCitations } from '../rag-B2oGudNb.js';
 import 'zod';
-import 'node:http';
+
+declare class DefaultRuntimeTurnRunner implements RuntimeTurnRunner {
+    run(input: RuntimeTurnInput, context: RuntimeTurnContext): Promise<RuntimeTurnResult>;
+}
+declare function createDefaultRuntimeTurnRunner(): RuntimeTurnRunner;
+
+interface ToolCallingRuntimeTurnRunnerOptions {
+    maxToolIterations?: number;
+}
+/**
+ * Runtime turn runner that executes provider-requested tools through the
+ * reusable runtime permission and event pipeline.
+ */
+declare class ToolCallingRuntimeTurnRunner implements RuntimeTurnRunner {
+    private readonly maxToolIterations;
+    constructor(options?: ToolCallingRuntimeTurnRunnerOptions);
+    run(input: RuntimeTurnInput, context: RuntimeTurnContext): Promise<RuntimeTurnResult>;
+}
+declare function createToolCallingRuntimeTurnRunner(options?: ToolCallingRuntimeTurnRunnerOptions): RuntimeTurnRunner;
+
+declare class InMemoryEventLog implements EventLog {
+    private events;
+    record(type: RuntimeEventType, data?: Record<string, unknown>): RuntimeEvent;
+    list(): RuntimeEvent[];
+    count(): number;
+    clear(): void;
+}
+declare class FileEventLog implements EventLog {
+    private readonly filePath;
+    private memory;
+    private writable;
+    constructor(filePath: string);
+    record(type: RuntimeEventType, data?: Record<string, unknown>): RuntimeEvent;
+    list(): RuntimeEvent[];
+    count(): number;
+    clear(): void;
+}
+declare function createEventLog(): EventLog;
+declare function createFileEventLog(filePath: string): EventLog;
+
+interface RuntimeHttpServerOptions {
+    maxBodyBytes?: number;
+}
+declare function createRuntimeHttpServer(runtime: AgentRuntime, options?: RuntimeHttpServerOptions): Server;
+
+declare class DefaultPermissionPolicy implements PermissionPolicy {
+    canExecuteTool(mode: RuntimeMode, tool: ToolDefinition): PermissionDecision;
+    canExecuteToolInput(mode: RuntimeMode, tool: ToolDefinition, input: Record<string, unknown>): PermissionDecision;
+}
+declare function createPermissionPolicy(): PermissionPolicy;
 
 interface PostgresQueryClient {
     query<T = unknown>(sql: string, params?: unknown[]): Promise<{
@@ -15,6 +65,23 @@ interface PostgresQueryClient {
 }
 interface PostgresRuntimeStoreOptions {
     tenantId?: string;
+    hostMode?: RuntimeHostMode;
+}
+interface RuntimeAuditRecord {
+    id: string;
+    tenantId: string;
+    type: string;
+    timestamp: string;
+    subject?: string;
+    data: Record<string, unknown>;
+}
+interface RuntimeAuditStore {
+    record(input: {
+        type: string;
+        subject?: string;
+        data?: Record<string, unknown>;
+    }): Promise<RuntimeAuditRecord>;
+    list(): Promise<RuntimeAuditRecord[]>;
 }
 declare class PostgresRuntimeSessionStore implements RuntimeSessionStore {
     private readonly client;
@@ -27,6 +94,16 @@ declare class PostgresRuntimeSessionStore implements RuntimeSessionStore {
     list(): RuntimeSession[];
     delete(id: string): boolean;
 }
+declare class AsyncPostgresRuntimeSessionStore implements AsyncRuntimeSessionStore {
+    private readonly client;
+    private readonly tenantId;
+    constructor(client: PostgresQueryClient, options: PostgresRuntimeStoreOptions);
+    create(options?: RuntimeSessionCreateOptions): Promise<RuntimeSession>;
+    get(id: string): Promise<RuntimeSession | undefined>;
+    update(session: RuntimeSession): Promise<RuntimeSession>;
+    list(): Promise<RuntimeSession[]>;
+    delete(id: string): Promise<boolean>;
+}
 /**
  * Async helper for hosted products that need to inspect persisted sessions.
  * RuntimeSessionStore remains sync for local runtime compatibility.
@@ -45,10 +122,203 @@ declare class PostgresEventLog implements EventLog {
     count(): number;
     clear(): void;
 }
+declare class AsyncPostgresEventLog implements AsyncEventLog {
+    private readonly client;
+    private readonly tenantId;
+    constructor(client: PostgresQueryClient, options: PostgresRuntimeStoreOptions);
+    record(type: RuntimeEventType, data?: Record<string, unknown>): Promise<RuntimeEvent>;
+    list(): Promise<RuntimeEvent[]>;
+    count(): Promise<number>;
+    clear(): Promise<void>;
+}
+declare class PostgresRuntimeAuditStore implements RuntimeAuditStore {
+    private readonly client;
+    private readonly tenantId;
+    constructor(client: PostgresQueryClient, options: PostgresRuntimeStoreOptions);
+    record(input: {
+        type: string;
+        subject?: string;
+        data?: Record<string, unknown>;
+    }): Promise<RuntimeAuditRecord>;
+    list(): Promise<RuntimeAuditRecord[]>;
+}
 declare function createPostgresRuntimeSessionStore(client: PostgresQueryClient, options?: PostgresRuntimeStoreOptions): RuntimeSessionStore;
 declare function createPostgresEventLog(client: PostgresQueryClient, options?: PostgresRuntimeStoreOptions): EventLog;
+declare function createAsyncPostgresRuntimeSessionStore(client: PostgresQueryClient, options: PostgresRuntimeStoreOptions): AsyncRuntimeSessionStore;
+declare function createAsyncPostgresEventLog(client: PostgresQueryClient, options: PostgresRuntimeStoreOptions): AsyncEventLog;
+declare function createPostgresRuntimeAuditStore(client: PostgresQueryClient, options: PostgresRuntimeStoreOptions): RuntimeAuditStore;
 declare function listPostgresRuntimeEvents(client: PostgresQueryClient, options?: PostgresRuntimeStoreOptions & {
     sessionId?: string;
 }): Promise<RuntimeEvent[]>;
 
-export { EventLog, PostgresEventLog, type PostgresQueryClient, PostgresRuntimeSessionStore, type PostgresRuntimeStoreOptions, RuntimeEvent, RuntimeEventType, RuntimeSession, RuntimeSessionCreateOptions, RuntimeSessionStore, createPostgresEventLog, createPostgresRuntimeSessionQueries, createPostgresRuntimeSessionStore, listPostgresRuntimeEvents };
+interface TenantScopeOptions {
+    tenantId: string;
+}
+declare class TenantScopedRuntimeSessionStore implements RuntimeSessionStore {
+    private readonly inner;
+    private readonly options;
+    constructor(inner: RuntimeSessionStore, options: TenantScopeOptions);
+    create(options?: RuntimeSessionCreateOptions): RuntimeSession;
+    get(id: string): RuntimeSession | undefined;
+    update(session: RuntimeSession): RuntimeSession;
+    list(): RuntimeSession[];
+    delete(id: string): boolean;
+    private withTenant;
+    private belongsToTenant;
+}
+declare class TenantScopedEventLog implements EventLog {
+    private readonly inner;
+    private readonly options;
+    constructor(inner: EventLog, options: TenantScopeOptions);
+    record(type: RuntimeEventType, data?: Record<string, unknown>): RuntimeEvent;
+    list(): RuntimeEvent[];
+    count(): number;
+    clear(): void;
+}
+declare function createTenantScopedRuntimeSessionStore(inner: RuntimeSessionStore, tenantId: string): RuntimeSessionStore;
+declare function createTenantScopedEventLog(inner: EventLog, tenantId: string): EventLog;
+
+declare class InMemoryRuntimeSessionStore implements RuntimeSessionStore {
+    private sessions;
+    create(options?: RuntimeSessionCreateOptions): RuntimeSession;
+    get(id: string): RuntimeSession | undefined;
+    update(session: RuntimeSession): RuntimeSession;
+    list(): RuntimeSession[];
+    delete(id: string): boolean;
+}
+declare class FileRuntimeSessionStore implements RuntimeSessionStore {
+    private readonly filePath;
+    private sessions;
+    constructor(filePath: string);
+    create(options?: RuntimeSessionCreateOptions): RuntimeSession;
+    get(id: string): RuntimeSession | undefined;
+    update(session: RuntimeSession): RuntimeSession;
+    list(): RuntimeSession[];
+    delete(id: string): boolean;
+    private readSessionsFromDisk;
+    private persist;
+}
+declare function createRuntimeSessionStore(): RuntimeSessionStore;
+declare function createFileRuntimeSessionStore(filePath: string): RuntimeSessionStore;
+
+type ExtensionRisk = "read-only" | "write" | "network" | "destructive" | "secrets-sensitive";
+type AgentSurface = "coco" | "claude" | "codex" | "gemini" | "opencode";
+interface SkillManifest {
+    name: string;
+    description: string;
+    triggers: string[];
+    requiredTools: string[];
+    risk: ExtensionRisk;
+    compatibleAgents: AgentSurface[];
+    sourcePath?: string;
+}
+interface RecipeStep {
+    id: string;
+    description: string;
+    requiredTools?: string[];
+    check?: string;
+}
+interface RecipeManifest {
+    name: string;
+    description: string;
+    inputs: string[];
+    suggestedModels?: string[];
+    steps: RecipeStep[];
+    checks: string[];
+    risk: ExtensionRisk;
+}
+interface McpToolPolicy {
+    server: string;
+    tool: string;
+    risk: ExtensionRisk;
+    requiresConfirmation: boolean;
+    allowedModes: string[];
+}
+declare function createMcpToolPolicy(server: string, tool: string, risk: ExtensionRisk, allowedModes?: string[]): McpToolPolicy;
+
+interface RuntimeToolExecutorOptions {
+    toolRegistry: ToolRegistry;
+    eventLog?: EventLog;
+    permissionPolicy?: PermissionPolicy;
+    mode?: RuntimeMode;
+    runtimePolicy?: RuntimePolicy;
+}
+interface RuntimeToolExecutorInput {
+    toolName: string;
+    input: Record<string, unknown>;
+    mode?: RuntimeMode;
+    allowedTools?: string[];
+    confirmed?: boolean;
+    metadata?: Record<string, unknown>;
+}
+declare class RuntimeToolExecutor {
+    private readonly toolRegistry;
+    private readonly eventLog;
+    private readonly permissionPolicy;
+    private readonly defaultMode;
+    private readonly runtimePolicy?;
+    constructor(options: RuntimeToolExecutorOptions);
+    execute(input: RuntimeToolExecutorInput): Promise<RuntimeToolExecutionResult>;
+    private block;
+}
+declare function createRuntimeToolExecutor(options: RuntimeToolExecutorOptions): RuntimeToolExecutor;
+
+type RuntimeSpanKind = "workflow" | "agent" | "llm" | "tool" | "rag" | "gate" | "handoff" | "state" | "runtime";
+interface RuntimeSpan {
+    id: string;
+    traceId: string;
+    spanId: string;
+    parentSpanId?: string;
+    kind: RuntimeSpanKind;
+    name: string;
+    timestamp: string;
+    attributes: Record<string, unknown>;
+}
+interface RuntimeTraceExporter {
+    export(span: RuntimeSpan): Promise<void>;
+    flush?(): Promise<void>;
+}
+interface RuntimeMetricsSnapshot {
+    events: number;
+    byKind: Record<RuntimeSpanKind, number>;
+    tokens: {
+        input: number;
+        output: number;
+    };
+    estimatedCostUsd: number;
+    retries: number;
+    policyBlocks: number;
+    errorsByClass: Record<string, number>;
+    toolsUsed: Record<string, number>;
+    gatesFailed: number;
+    tenantUsage: Record<string, {
+        events: number;
+        inputTokens: number;
+        outputTokens: number;
+        estimatedCostUsd: number;
+    }>;
+}
+declare class InMemoryTraceExporter implements RuntimeTraceExporter {
+    private spans;
+    export(span: RuntimeSpan): Promise<void>;
+    list(): RuntimeSpan[];
+    clear(): void;
+}
+declare class FileTraceExporter implements RuntimeTraceExporter {
+    private readonly filePath;
+    constructor(filePath: string);
+    export(span: RuntimeSpan): Promise<void>;
+    list(): RuntimeSpan[];
+    clear(): void;
+}
+declare class OpenTelemetryTraceExporter implements RuntimeTraceExporter {
+    private spans;
+    export(span: RuntimeSpan): Promise<void>;
+    toOtlpJson(): Record<string, unknown>;
+}
+declare function exportRuntimeEventsAsSpans(events: RuntimeEvent[], exporter: RuntimeTraceExporter): Promise<RuntimeSpan[]>;
+declare function eventToSpan(event: RuntimeEvent): RuntimeSpan;
+declare function collectRuntimeMetrics(events: RuntimeEvent[]): RuntimeMetricsSnapshot;
+declare function redactTraceAttributes(input: Record<string, unknown>): Record<string, unknown>;
+
+export { AgentRuntime, type AgentSurface, AsyncEventLog, AsyncPostgresEventLog, AsyncPostgresRuntimeSessionStore, AsyncRuntimeSessionStore, DefaultPermissionPolicy, DefaultRuntimeTurnRunner, EventLog, type ExtensionRisk, FileEventLog, FileRuntimeSessionStore, FileTraceExporter, InMemoryEventLog, InMemoryRuntimeSessionStore, InMemoryTraceExporter, type McpToolPolicy, OpenTelemetryTraceExporter, PermissionDecision, PermissionPolicy, PostgresEventLog, type PostgresQueryClient, PostgresRuntimeAuditStore, PostgresRuntimeSessionStore, type PostgresRuntimeStoreOptions, type RecipeManifest, type RecipeStep, type RuntimeAuditRecord, type RuntimeAuditStore, RuntimeEvent, RuntimeEventType, RuntimeHostMode, type RuntimeHttpServerOptions, type RuntimeMetricsSnapshot, RuntimeMode, RuntimePolicy, RuntimeSession, RuntimeSessionCreateOptions, RuntimeSessionStore, type RuntimeSpan, type RuntimeSpanKind, RuntimeToolExecutionResult, RuntimeToolExecutor, type RuntimeToolExecutorInput, type RuntimeToolExecutorOptions, type RuntimeTraceExporter, RuntimeTurnContext, RuntimeTurnInput, RuntimeTurnResult, RuntimeTurnRunner, type SkillManifest, type TenantScopeOptions, TenantScopedEventLog, TenantScopedRuntimeSessionStore, ToolCallingRuntimeTurnRunner, type ToolCallingRuntimeTurnRunnerOptions, collectRuntimeMetrics, createAsyncPostgresEventLog, createAsyncPostgresRuntimeSessionStore, createDefaultRuntimeTurnRunner, createEventLog, createFileEventLog, createFileRuntimeSessionStore, createMcpToolPolicy, createPermissionPolicy, createPostgresEventLog, createPostgresRuntimeAuditStore, createPostgresRuntimeSessionQueries, createPostgresRuntimeSessionStore, createRuntimeHttpServer, createRuntimeSessionStore, createRuntimeToolExecutor, createTenantScopedEventLog, createTenantScopedRuntimeSessionStore, createToolCallingRuntimeTurnRunner, eventToSpan, exportRuntimeEventsAsSpans, listPostgresRuntimeEvents, redactTraceAttributes };