@ai-ecoverse/slicc-agent 3.27.1 → 3.29.0

package/dist/types/mcp/connection.d.ts

@@ -0,0 +1,57 @@
+import { type CallToolResult, type ListResourcesResult, type ListResourceTemplatesResult, McpClient, type McpRequestOptions, type Tool as McpTool, type McpTransport, type ReadResourceResult, type Resource, type ResourceTemplate } from '@earendil-works/pi-mcp';
+import { type McpServerEntry } from './config.ts';
+export type ServerState = 'connecting' | 'connected' | 'needs-auth' | 'needs-secret' | 'failed' | 'closed';
+export type TransportFactory = (entry: McpServerEntry) => Promise<{
+    transport: McpTransport;
+    secrets: string[];
+} | {
+    missing: string[];
+}>;
+export declare const CONNECT_RETRY_DELAYS_MS: number[];
+export declare const CLIENT_NAME = "slicc";
+export declare function errorMessage(error: unknown): string;
+export declare function isTransient(error: unknown): boolean;
+export declare function isMcpApp(item: {
+    uri?: string;
+    uriTemplate?: string;
+    mimeType?: string;
+}): boolean;
+export interface ConnectionOptions {
+    entry: McpServerEntry;
+    version: string;
+    transport: TransportFactory;
+    onTools: (connection: McpServerConnection) => void;
+    onChange?: (connection: McpServerConnection) => void;
+    onLog?: (connection: McpServerConnection, params: unknown) => void;
+}
+export declare class McpServerConnection {
+    #private;
+    readonly entry: McpServerEntry;
+    state: ServerState;
+    error: string | undefined;
+    missing: string[];
+    tools: McpTool[];
+    hasResources: boolean;
+    resources: Resource[];
+    resourceTemplates: ResourceTemplate[];
+    instructions: string | undefined;
+    secrets: string[];
+    constructor(options: ConnectionOptions);
+    get name(): string;
+    get timeoutMs(): number;
+    get live(): boolean;
+    get closed(): boolean;
+    getClient(): Promise<McpClient>;
+    callTool(name: string, args: Record<string, unknown>, options: McpRequestOptions): Promise<CallToolResult>;
+    readResource(uri: string, options: McpRequestOptions): Promise<ReadResourceResult>;
+    resourcesPage(cursor: string | undefined, options: McpRequestOptions): Promise<ListResourcesResult>;
+    resourceTemplatesPage(cursor: string | undefined, options: McpRequestOptions): Promise<ListResourceTemplatesResult>;
+    allResources(options: McpRequestOptions): Promise<Resource[]>;
+    allResourceTemplates(options: McpRequestOptions): Promise<ResourceTemplate[]>;
+    signInMessage(): string;
+    close(): Promise<void>;
+}
+export declare class MissingSecret extends Error {
+    readonly names: string[];
+    constructor(names: string[]);
+}

package/dist/types/mcp/content.d.ts

@@ -0,0 +1,27 @@
+import type { Context } from '@earendil-works/chord';
+import type { ImageContent, TextContent } from '@earendil-works/pi-ai';
+import { type CallToolResult, type ContentBlock } from '@earendil-works/pi-mcp';
+export declare const MCP_OUTPUT_MAX_BYTES: number;
+export declare const READ_MCP_RESOURCE = "read_mcp_resource";
+export type Content = TextContent | ImageContent;
+export type Saver = (data: string | Uint8Array, extension: string) => Promise<string>;
+export interface Truncation {
+    content: string;
+    truncated: boolean;
+    totalBytes: number;
+    totalLines: number;
+}
+export declare function formatSize(bytes: number): string;
+export declare function truncateMiddle(content: string, maxBytes: number): Truncation;
+export declare function limitContent(content: Content[], save: Saver): Promise<{
+    content: Content[];
+    fullOutputPath?: string;
+}>;
+export declare function modelContent(server: string, blocks: readonly ContentBlock[], save: Saver, readable?: boolean): Promise<Content[]>;
+export declare function convertResult(server: string, tool: string, result: CallToolResult, save: Saver, readable?: boolean): Promise<{
+    content: Content[];
+    isError: boolean;
+    fullOutputPath?: string;
+}>;
+export declare function scriptResult(result: CallToolResult): Record<string, unknown>;
+export declare function spiller(write: (path: string, data: string | Uint8Array, context: Context) => Promise<boolean>, id: () => string, context: Context): Saver;

package/dist/types/mcp/credentials.d.ts

@@ -0,0 +1,15 @@
+import type { CredentialStore } from '@earendil-works/pi-ai';
+import { type McpServerConfig } from './config.ts';
+export declare const MCP_CREDENTIAL_PREFIX = "mcp:";
+export declare function credentialKey(server: string, url: string): Promise<string>;
+export declare function secretNames(config: McpServerConfig): string[];
+export type Resolved = {
+    ok: true;
+    headers: Record<string, string>;
+    secrets: string[];
+} | {
+    ok: false;
+    missing: string[];
+};
+export declare function resolveHeaders(server: string, config: McpServerConfig, credentials: CredentialStore): Promise<Resolved>;
+export declare function scrub(text: string, secrets: readonly string[]): string;

package/dist/types/mcp/index.d.ts

@@ -0,0 +1,16 @@
+import type { Context } from '@earendil-works/chord';
+import type { Agent, Registry, ToolExecutionApi, ToolRegistration } from '@earendil-works/pi-durable';
+import type { CodemodeExtra } from './allow.ts';
+import type { McpCatalog } from './catalog.ts';
+import type { McpAttach, McpRuntime } from './runtime.ts';
+export { allows, type CodemodeExtra, McpAllowDoc, mcpEntries, serverAllowed } from './allow.ts';
+export type { McpAttach, McpRuntime, ServerStatus } from './runtime.ts';
+export type McpLoader = () => Promise<typeof import('./runtime.ts')>;
+export declare const loadRuntime: McpLoader;
+export interface McpSetup {
+    catalog(): McpCatalog | undefined;
+    direct(names: readonly string[]): ToolRegistration[];
+    codemode(api: ToolExecutionApi, agent: Agent, context: Context): Promise<CodemodeExtra>;
+    attach(options: McpAttach, context: Context): Promise<McpRuntime>;
+}
+export declare function setupMcp(registry: Registry, load?: McpLoader): McpSetup;

package/dist/types/mcp/runtime.d.ts

@@ -0,0 +1,42 @@
+import type { Context } from '@earendil-works/chord';
+import type { CredentialStore } from '@earendil-works/pi-ai';
+import type { Registry } from '@earendil-works/pi-durable';
+import type { ExecutionEnv } from '@earendil-works/pi-durable/env';
+import type { LickEvent, Licks } from '../licks/licks.ts';
+import { McpCatalog } from './catalog.ts';
+import { type McpConfigProblem } from './config.ts';
+import { McpServerConnection } from './connection.ts';
+export declare const MCP_LOG_MAX_BYTES: number;
+export declare function configPath(home: string): string;
+export declare function logPath(home: string): string;
+export interface McpAttach {
+    licks: Licks;
+    env: ExecutionEnv;
+    home: string;
+    credentials: CredentialStore;
+    fetch: typeof fetch;
+    version: string;
+    reloadMs: number;
+    codemode: boolean;
+    cors: boolean;
+}
+export interface ServerStatus {
+    name: string;
+    state: string;
+    tools: number;
+    error?: string;
+}
+export interface McpRuntime {
+    status(): ServerStatus[];
+    reload(context: Context): Promise<void>;
+    close(context: Context): Promise<void>;
+}
+export declare function problemLick(problem: McpConfigProblem, home: string): LickEvent;
+export declare function stateLick(connection: McpServerConnection, cors: boolean): LickEvent | undefined;
+export declare function connectedLick(connection: McpServerConnection): LickEvent;
+export declare function logLine(server: string, params: unknown, secrets: readonly string[], at: Date): string;
+export declare function attachMcp(catalog: McpCatalog, options: McpAttach, context: Context): Promise<McpRuntime>;
+export declare function startMcp(registry: Registry, options: McpAttach, context: Context): Promise<{
+    catalog: McpCatalog;
+    runtime: McpRuntime;
+}>;

package/dist/types/mcp/section.d.ts

@@ -0,0 +1,7 @@
+export interface Listing {
+    name: string;
+    description?: string;
+    instructions?: string;
+}
+export declare const SECTION_INTRO: string;
+export declare function renderSection(listed: readonly Listing[]): string | undefined;

package/dist/types/mcp/sse.d.ts

@@ -0,0 +1,16 @@
+export interface SseEvent {
+    event?: string;
+    data: string;
+    id?: string;
+}
+export interface SseOptions {
+    maxEventBytes?: number;
+    onEvent(event: SseEvent): void;
+    onId?(id: string): void;
+    onRetry?(ms: number): void;
+}
+export declare function sseField(raw: string): [string, string] | undefined;
+export declare function readSse(stream: ReadableStream<Uint8Array>, options: SseOptions): Promise<void>;
+export declare function patchSse(target?: {
+    prototype: object;
+}): void;

package/dist/types/mcp/tools.d.ts

@@ -0,0 +1,44 @@
+import type { Context } from '@earendil-works/chord';
+import { type CodemodeJsonSchema, type CodemodeTool } from '@earendil-works/pi-codemode';
+import { type ToolExecutionApi, type ToolRegistration } from '@earendil-works/pi-durable';
+import type { Tool as McpTool } from '@earendil-works/pi-mcp';
+import type { McpExposure } from './config.ts';
+import { type McpServerConnection } from './connection.ts';
+import { READ_MCP_RESOURCE, type Saver } from './content.ts';
+export declare const LIST_MCP_RESOURCES = "list_mcp_resources";
+export declare const LIST_MCP_RESOURCE_TEMPLATES = "list_mcp_resource_templates";
+export { READ_MCP_RESOURCE };
+export interface McpToolEntry {
+    server: string;
+    name: string;
+    exposure: McpExposure;
+    tool: McpTool;
+    connection: McpServerConnection;
+}
+export type McpDetails = {
+    server: string;
+    tool: string;
+    fullOutputPath?: string;
+};
+export declare function resultSchema(structured: Record<string, unknown> | undefined): CodemodeJsonSchema;
+export declare function apiSaver(api: ToolExecutionApi, prefix: string, context: Context): Saver;
+export declare function directTool(entry: McpToolEntry, readable: () => boolean): ToolRegistration;
+export declare function scriptTool(entry: McpToolEntry, signal: AbortSignal | undefined): CodemodeTool;
+export interface ResourceServer {
+    name: string;
+    connection: McpServerConnection;
+}
+export type ServersFor = (api: ToolExecutionApi, context: Context) => Promise<readonly ResourceServer[]>;
+export declare function resourceTools(servers: ServersFor): ToolRegistration[];
+export declare function resourceScriptTools(servers: () => readonly ResourceServer[], signal: AbortSignal | undefined, save: Saver): CodemodeTool[];
+export interface Namespace {
+    name: string;
+    description?: string;
+    instructions?: string;
+}
+export declare function rank(query: string, documents: readonly {
+    name: string;
+    text: string;
+}[], limit: number): string[];
+export declare const DEFAULT_SEARCH_LIMIT = 8;
+export declare function discoveryGlobals(tools: readonly CodemodeTool[], namespaceOf: (tool: string) => Namespace | undefined): CodemodeTool[];

package/dist/types/patches.d.ts

@@ -1,4 +1,5 @@
 declare const applied: unique symbol;
+export declare const MCP_SSE_PATCH = "pi-mcp-sse-buffer";
 interface Patchable {
     prototype: {
         accept: (...args: unknown[]) => unknown;

package/dist/types/scoops/index.d.ts

@@ -28,6 +28,7 @@ export interface AttachOptions {
     memory?: CliOptions['memory'];
     gelatiere?: CliOptions['gelatiere'];
     freezer?: CliOptions['freezer'];
+    mcp?: (names: readonly string[]) => ToolRegistration[];
 }
 export interface ScoopsRuntime {
     roles(context: Context): Promise<Roles>;

package/dist/types/scoops/service.d.ts

@@ -49,6 +49,7 @@ export interface ScoopsHost {
     tools?: readonly ToolRegistration[];
     reads?: () => readonly string[];
     files?: Pick<ExecutionEnv, 'remove' | 'createDir'>;
+    mcp?: (names: readonly string[]) => ToolRegistration[];
 }
 export interface Rewound {
     stopped: string[];

package/dist/types/services.d.ts

@@ -41,11 +41,13 @@ export interface AgentControl {
     }>;
     abort(context: Context): Promise<void>;
     compact(instructions: string | null, context: Context): Promise<SendResponse>;
+    compactAgent(agentId: string, instructions: string | null, context: Context): Promise<SendResponse>;
     reset(handoff: string | null, context: Context): Promise<void>;
     configure(change: AgentSettingsChange, context: Context): Promise<void>;
     rewind(messageId: string | null, context: Context): Promise<Rewound>;
     rewindAgent(agentId: string, messageId: string | null, context: Context): Promise<Rewound>;
     resolveLick(lickId: string, state: 'confirmed' | 'dismissed', context: Context): Promise<LickResolved>;
+    resolveAgentLick(agentId: string, lickId: string, state: 'confirmed' | 'dismissed', context: Context): Promise<LickResolved>;
     webhook(name: string, delivery: WebhookRequest, context: Context): Promise<{
         delivered: boolean;
     }>;

package/dist/types/spectrum/agent-port.d.ts

@@ -19,7 +19,7 @@ export declare class AgentAdapter extends Emitter<AgentEvents> implements AgentP
     suggestion(): string | null;
     answer(): void;
     resolveLick(agentId: string, messageId: string, state: 'confirmed' | 'dismissed'): void;
-    compact(): void;
+    compact(agentId?: string): void;
     clear(agentId?: string): void;
     freeze(agentId?: string): void;
     setModel(agentId: string, model: string): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-ecoverse/slicc-agent",
-  "version": "3.27.1",
+  "version": "3.29.0",
   "description": "SLICC's agent core on pi durable: an agent worker, session storage, remoting and pi extensions",
   "type": "module",
   "license": "Apache-2.0",
@@ -62,11 +62,11 @@
   },
   "devDependencies": {
     "@ai-ecoverse/slicc-kernel": "1.26.3",
-    "@ai-ecoverse/slicc-shared-web": "1.11.0",
-    "@ai-ecoverse/slicc-spectrum": "1.44.0",
-    "@ai-ecoverse/wasm-bash": "5.3.0-10",
+    "@ai-ecoverse/slicc-shared-web": "1.12.0",
+    "@ai-ecoverse/slicc-spectrum": "1.46.0",
+    "@ai-ecoverse/wasm-bash": "5.3.0-11",
     "@ai-ecoverse/wasm-coreutils": "9.7.0-3",
-    "@ai-ecoverse/wasm-git": "2.55.0-11",
+    "@ai-ecoverse/wasm-git": "2.55.0-12",
     "@biomejs/biome": "2.5.15",
     "@types/node": "24.19.1",
     "esbuild": "0.28.2",
@@ -83,6 +83,7 @@
     "@earendil-works/pi-client": "1.0.4",
     "@earendil-works/pi-codemode": "1.1.0",
     "@earendil-works/pi-durable": "1.0.4",
+    "@earendil-works/pi-mcp": "1.1.0",
     "@earendil-works/pi-protocol": "1.0.4",
     "@earendil-works/pi-server": "1.0.4",
     "@sqlite.org/sqlite-wasm": "3.53.4-build2"