@ai-ecoverse/slicc-agent 3.52.1 → 4.1.0

package/dist/titles/generate.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/titles/generate.ts"],
+  "sourcesContent": ["import type { Context } from '@earendil-works/chord';\nimport type { Message } from '@earendil-works/pi-ai';\nimport type { Models } from '@earendil-works/pi-ai/models';\nimport type { EntryRecord } from '@earendil-works/pi-durable';\nimport type { ExecutionEnv } from '@earendil-works/pi-durable/env';\nimport { answerText } from '../agent.ts';\nimport { extractSettings } from '../memory/extract.ts';\nimport { redactSecrets } from '../memory/format.ts';\nimport { scrubText } from '../secrets/scrub.ts';\n\nexport const TITLE_PROMPT =\n  'Give this chat a title of three to six words that says what it is about, in the language the user writes in. Answer with the title only, without quotes.';\n\nexport const TRANSCRIPT_LENGTH = 4000;\n\nexport function titlesOn(text: string | undefined): boolean {\n  try {\n    return (JSON.parse(text ?? '{}') as { titles?: unknown }).titles !== false;\n  } catch {\n    return true;\n  }\n}\n\nexport function settingsText(\n  env: Pick<ExecutionEnv, 'readTextFile'>,\n  home: string,\n  dir = `${home}/.pi/agent`\n): (context: Context) => Promise<string | undefined> {\n  return async (context) => {\n    const read = await env.readTextFile(`${dir}/settings.json`, context);\n    return read.ok ? read.value : undefined;\n  };\n}\n\nfunction textOf(entry: EntryRecord): string {\n  return answerText(entry.model?.[0]?.content).trim();\n}\n\nexport function transcriptOf(entries: readonly EntryRecord[]): string {\n  return entries\n    .filter((entry) => entry.kind === 'pi.user' || entry.kind === 'pi.assistant')\n    .map((entry) => `${entry.kind === 'pi.user' ? 'User' : 'Agent'}: ${textOf(entry)}`)\n    .join('\\n');\n}\n\nexport async function scrubTranscript(entries: readonly EntryRecord[]): Promise<string> {\n  const raw = transcriptOf(entries);\n  const redacted = redactSecrets(raw).text;\n  const scrubbed = await scrubText(redacted);\n  return scrubbed.slice(0, TRANSCRIPT_LENGTH);\n}\n\nexport function titler(\n  models: Models,\n  settings: (context: Context) => Promise<string | undefined>\n) {\n  return async (\n    transcript: string,\n    model: string,\n    context: Context\n  ): Promise<string | undefined> => {\n    const text = await settings(context);\n    if (!titlesOn(text)) return undefined;\n    const chosen = extractSettings(text).model;\n    const [provider, ...rest] = model.split('/');\n    const ref = chosen ?? (provider && rest.length ? { provider, modelId: rest.join('/') } : null);\n    const found = ref ? models.getModel(ref.provider, ref.modelId) : undefined;\n    if (!found || !transcript) return undefined;\n    const message = await models.completeSimple(\n      found,\n      {\n        messages: [\n          {\n            role: 'user',\n            content: [{ type: 'text', text: `${TITLE_PROMPT}\\n\\n${transcript}` }],\n            timestamp: Date.now(),\n          } as Message,\n        ],\n      },\n      { maxTokens: 40 }\n    );\n    if (message.stopReason === 'error') return undefined;\n    return message.content\n      .map((part) => (part.type === 'text' ? part.text : ''))\n      .join('')\n      .trim();\n  };\n}\n"],
+  "mappings": "AAKA,SAAS,kBAAkB;AAC3B,SAAS,uBAAuB;AAChC,SAAS,qBAAqB;AAC9B,SAAS,iBAAiB;AAEnB,MAAM,eACX;AAEK,MAAM,oBAAoB;AAE1B,SAAS,SAAS,MAAmC;AAC1D,MAAI;AACF,WAAQ,KAAK,MAAM,QAAQ,IAAI,EAA2B,WAAW;AAAA,EACvE,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAEO,SAAS,aACd,KACA,MACA,MAAM,GAAG,IAAI,cACsC;AACnD,SAAO,OAAO,YAAY;AACxB,UAAM,OAAO,MAAM,IAAI,aAAa,GAAG,GAAG,kBAAkB,OAAO;AACnE,WAAO,KAAK,KAAK,KAAK,QAAQ;AAAA,EAChC;AACF;AAEA,SAAS,OAAO,OAA4B;AAC1C,SAAO,WAAW,MAAM,QAAQ,CAAC,GAAG,OAAO,EAAE,KAAK;AACpD;AAEO,SAAS,aAAa,SAAyC;AACpE,SAAO,QACJ,OAAO,CAAC,UAAU,MAAM,SAAS,aAAa,MAAM,SAAS,cAAc,EAC3E,IAAI,CAAC,UAAU,GAAG,MAAM,SAAS,YAAY,SAAS,OAAO,KAAK,OAAO,KAAK,CAAC,EAAE,EACjF,KAAK,IAAI;AACd;AAEA,eAAsB,gBAAgB,SAAkD;AACtF,QAAM,MAAM,aAAa,OAAO;AAChC,QAAM,WAAW,cAAc,GAAG,EAAE;AACpC,QAAM,WAAW,MAAM,UAAU,QAAQ;AACzC,SAAO,SAAS,MAAM,GAAG,iBAAiB;AAC5C;AAEO,SAAS,OACd,QACA,UACA;AACA,SAAO,OACL,YACA,OACA,YACgC;AAChC,UAAM,OAAO,MAAM,SAAS,OAAO;AACnC,QAAI,CAAC,SAAS,IAAI,EAAG,QAAO;AAC5B,UAAM,SAAS,gBAAgB,IAAI,EAAE;AACrC,UAAM,CAAC,UAAU,GAAG,IAAI,IAAI,MAAM,MAAM,GAAG;AAC3C,UAAM,MAAM,WAAW,YAAY,KAAK,SAAS,EAAE,UAAU,SAAS,KAAK,KAAK,GAAG,EAAE,IAAI;AACzF,UAAM,QAAQ,MAAM,OAAO,SAAS,IAAI,UAAU,IAAI,OAAO,IAAI;AACjE,QAAI,CAAC,SAAS,CAAC,WAAY,QAAO;AAClC,UAAM,UAAU,MAAM,OAAO;AAAA,MAC3B;AAAA,MACA;AAAA,QACE,UAAU;AAAA,UACR;AAAA,YACE,MAAM;AAAA,YACN,SAAS,CAAC,EAAE,MAAM,QAAQ,MAAM,GAAG,YAAY;AAAA;AAAA,EAAO,UAAU,GAAG,CAAC;AAAA,YACpE,WAAW,KAAK,IAAI;AAAA,UACtB;AAAA,QACF;AAAA,MACF;AAAA,MACA,EAAE,WAAW,GAAG;AAAA,IAClB;AACA,QAAI,QAAQ,eAAe,QAAS,QAAO;AAC3C,WAAO,QAAQ,QACZ,IAAI,CAAC,SAAU,KAAK,SAAS,SAAS,KAAK,OAAO,EAAG,EACrD,KAAK,EAAE,EACP,KAAK;AAAA,EACV;AACF;",
+  "names": []
+}

package/dist/types/client.d.ts

@@ -6,7 +6,7 @@ import type { MemoryEntry, MemoryScope } from './memory/format.ts';
 import type { AgentRemote } from './remote/host.ts';
 import type { AgentPages } from './remote/pages.ts';
 import type { VaultState } from './secrets/vault.ts';
-import { AgentControl, AgentSettings, type AgentsSummary, type Command, type Delivered, type MonitorFeed, type SendMode } from './services.ts';
+import { AgentControl, AgentSettings, type AgentsSummary, type Command, type Delivered, type MonitorFeed, type PrivateRevision, type SendMode } from './services.ts';
 import type { Sprinkle } from './sprinkles/kind.ts';
 import { type PortEndpoint } from './wire.ts';
 export interface AgentConnection {
@@ -17,6 +17,7 @@ export interface AgentConnection {
     readonly agents?: ReplicatedState<AgentsSummary>;
     readonly views?: ReplicatedState<Record<string, ConversationView>>;
     readonly commands?: ReplicatedState<Command[]>;
+    readonly privateRevision?: ReplicatedState<PrivateRevision>;
     readonly sprinkles?: ReplicatedState<Sprinkle[]>;
     readonly memories?: ReplicatedState<MemoryEntry[]>;
     readonly memoryScopes?: ReplicatedState<MemoryScope[]>;

package/dist/types/control.d.ts

@@ -22,4 +22,4 @@ export interface HostScoops {
 }
 export declare function readable(out: string): string;
 export declare function submissionId(value: string): SubmissionId | undefined;
-export declare function createAgentControl(harness: Harness, target: Conversation | Cones, deliveries?: Deliveries, licks?: HostLicks, scoops?: HostScoops, skills?: Pick<SkillsRuntime, 'expand'>, sprinkles?: Pick<SprinklesRuntime, 'send' | 'call'>, memory?: Pick<MemoryRuntime, 'save' | 'remove'>, freezer?: Pick<FreezerRuntime, 'freeze' | 'newChat' | 'thaw' | 'discard'>, changes?: Pick<ChangesRuntime, 'open' | 'accept' | 'revert'>, monitor?: Pick<Monitor, 'open' | 'close'>, secrets?: () => readonly SecretName[], uploads?: Uploads): AgentControl;
+export declare function createAgentControl(harness: Harness, target: Conversation | Cones, deliveries?: Deliveries, licks?: HostLicks, scoops?: HostScoops, skills?: Pick<SkillsRuntime, 'expand' | 'commandsFor'>, sprinkles?: Pick<SprinklesRuntime, 'send' | 'call'>, memory?: Pick<MemoryRuntime, 'save' | 'remove'>, freezer?: Pick<FreezerRuntime, 'freeze' | 'newChat' | 'thaw' | 'discard'>, changes?: Pick<ChangesRuntime, 'open' | 'accept' | 'revert'>, monitor?: Pick<Monitor, 'open' | 'close'>, secrets?: () => readonly SecretName[], uploads?: Uploads): AgentControl;

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

@@ -1,7 +1,7 @@
 import { type Context, type ReplicatedState } from '@earendil-works/chord';
 import type { EntryRecord, Harness } from '@earendil-works/pi-durable';
 import type { ExecutionEnv } from '@earendil-works/pi-durable/env';
-import { type Agents, type AgentsState, type ConeRecord, type FrozenRecord } from '../agents.ts';
+import { type Agents, type AgentsState, type FrozenRecord } from '../agents.ts';
 import { type Layout } from '../layout.ts';
 import type { LickTarget } from '../licks/lick.ts';
 export type Answer = {
@@ -32,6 +32,7 @@ export interface FreezerAttach {
     env: Pick<ExecutionEnv, 'remove' | 'exists'>;
     title?: (transcript: string, model: string, context: Context) => Promise<string | undefined>;
     extract?: (conversation: number, tail: number, context: Context, cone: string) => Promise<unknown>;
+    cancelTitle?: (agentId: string) => void;
     now?: () => number;
     layout?: Layout;
 }
@@ -48,7 +49,6 @@ export interface FreezerRuntime {
     close(): void;
 }
 export declare const USAGE = "usage:\n  freezer list         every conversation: id, kind, name, title, messages, when\n  freezer show <id>    a conversation as Markdown\n  freezer thaw <id>    continue a stopped conversation as a cone\n\nDelete a cone, or start a new conversation, from the chat toolbar or the command palette.\n";
-export declare const TITLE_TURNS: number[];
 export declare const TOUCH_MS = 500;
 export declare function modelName(model: {
     provider: string;
@@ -56,9 +56,6 @@ export declare function modelName(model: {
 } | undefined): string;
 export declare function firstLine(entries: readonly EntryRecord[]): string;
 export declare function markdown(record: Pick<FrozenRecord, 'title' | 'name' | 'model' | 'frozenAt'>, entries: readonly EntryRecord[]): string;
-export declare function trivial(text: string): boolean;
-export declare function titleDue(record: Pick<ConeRecord, 'titled'>, entries: readonly EntryRecord[], final?: boolean): number | undefined;
-export declare function cleanTitle(title: string | undefined): string | undefined;
 export declare function thawedNote(kind: ConversationKind, name: string, folder: string, kept: boolean, home?: string): string;
 export declare function frozenTarget(state: Readonly<AgentsState>, target: LickTarget): Frozen | undefined;
 export declare function attachFreezer(options: FreezerAttach): FreezerRuntime;

package/dist/types/host.d.ts

@@ -46,7 +46,7 @@ export declare function hostAgent(agent: Agent, options?: {
     changes?: ChangesRuntime;
     mcp?: Pick<McpRuntime, 'close'>;
     users?: UserClients;
-    monitor?: Pick<MonitorOptions, 'kernel' | 'groups' | 'users' | 'secrets'>;
+    monitor?: Pick<MonitorOptions, 'kernel' | 'groups' | 'users'>;
     pages?: Pages;
     secrets?: HostSecrets;
     uploads?: Uploads;

package/dist/types/index.d.ts

@@ -3,7 +3,6 @@ export { type Agent, type AgentOptions, answerText, openAgent } from './agent.ts
 export { FILE_LIMIT, IMAGE_LIMIT, type SendAttachment, type ShownAttachment, splitUser, TOTAL_LIMIT, userParts, } from './attachments.ts';
 export { type AgentConnection, connectAgent } from './client.ts';
 export { createAgentControl } from './control.ts';
-export { CREDENTIALS_DATABASE, EncryptedCredentialStore } from './credentials.ts';
 export { type AgentHost, type ConnectOptions, hostAgent } from './host.ts';
 export type { KernelClient, KernelFs, KernelProcess, KernelStat, SpawnOptions, } from './kernel/client.ts';
 export { HOME, type KernelEnvOptions, kernelEnvironment, SliccKernelEnv } from './kernel/env.ts';

package/dist/types/main.d.ts

@@ -1,4 +1,4 @@
-import type { CredentialStore, Provider } from '@earendil-works/pi-ai';
+import type { Provider } from '@earendil-works/pi-ai';
 import type { Models } from '@earendil-works/pi-ai/models';
 import { type ModelRef, type Storage } from '@earendil-works/pi-durable';
 import { type AgentHost } from './host.ts';
@@ -6,6 +6,9 @@ import type { KernelClient } from './kernel/client.ts';
 import { type UserClients } from './kernel/users.ts';
 import { type Transport } from './net.ts';
 import { type Assets } from './scoops/index.ts';
+import { type ModelBases } from './secrets/endpoints.ts';
+import { type PlainStore } from './secrets/store.ts';
+import { createSliccModels } from './settings.ts';
 import { type WorkerScope } from './worker.ts';
 export interface AgentWorkerScope extends WorkerScope {
     fetch: typeof fetch;
@@ -20,7 +23,7 @@ export interface AgentWorkerOptions {
     model?: ModelRef;
     providers?: Provider[];
     attach?: KernelAttach;
-    credentials?: () => Promise<CredentialStore>;
+    store?: () => Promise<PlainStore>;
     storage?: () => Promise<Storage>;
     assets?: Assets;
     codemodeWasm?: () => Promise<WebAssembly.Module | undefined>;
@@ -31,7 +34,9 @@ export interface AgentWorkerOptions {
 }
 export declare function usersOf(admin: MessagePort | undefined, wanted: boolean | undefined, attach: KernelAttach): UserClients | undefined;
 export declare const STORE_DIR = "/.slicc";
+export declare const ACCOUNTS_FILE = "/.slicc/accounts.json";
 export declare function seesImages(models: Pick<Models, 'getModel'>, ref: ModelRef | undefined): boolean;
 export declare const MCP_CALLBACK = "/oauth/mcp-callback";
+export declare function modelBases(providers: readonly Provider[], models: Pick<ReturnType<typeof createSliccModels>, 'getModels'>): ModelBases[];
 export declare function alive(client: KernelClient): (pid: number) => Promise<boolean>;
 export declare function runAgentWorker(scope: AgentWorkerScope, options?: AgentWorkerOptions): Promise<AgentHost>;

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

@@ -1,20 +1,26 @@
-import type { CredentialStore } from '@earendil-works/pi-ai';
+import type { Context } from '@earendil-works/chord';
 import type { McpFetch } from '@earendil-works/pi-mcp';
 import type { AccountState } from '../services.ts';
 import type { McpCatalog } from './catalog.ts';
 import type { McpServerEntry } from './config.ts';
 import type { McpServerConnection } from './connection.ts';
+import { type McpRecords } from './credentials.ts';
 import { type McpSignIn, type StoredOAuth } from './oauth.ts';
+export declare const TOKENS_IN_VAULT = "MCP tokens are kept in seven's vault: update seven";
 export interface McpAccounts {
     accounts(): Promise<AccountState[]>;
     signIn(id: string): Promise<McpSignIn>;
-    connect(id: string, secret: string): Promise<void>;
+    connect(id: string, secret: string | null): Promise<void>;
     disconnect(id: string): Promise<void>;
     onChange(listener: () => void): () => void;
 }
 export interface AccountSources {
-    credentials: CredentialStore;
+    records: McpRecords & {
+        refresh(context: Context): Promise<void>;
+    };
     oauth: (entry: McpServerEntry) => StoredOAuth;
-    fetch: McpFetch;
+    fetch: (server: string) => McpFetch;
+    grant: (server: string) => McpFetch;
+    register: (server: string, tokenUrl: string) => Promise<void>;
 }
 export declare function mcpAccounts(catalog: McpCatalog, sources: AccountSources, restart: (connection: McpServerConnection) => void, listeners: Set<() => void>): McpAccounts;

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

@@ -3,7 +3,6 @@ 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[];
 }>;
@@ -36,7 +35,6 @@ export declare class McpServerConnection {
     resources: Resource[];
     resourceTemplates: ResourceTemplate[];
     instructions: string | undefined;
-    secrets: string[];
     constructor(options: ConnectionOptions);
     get name(): string;
     get timeoutMs(): number;

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

@@ -1,15 +1,17 @@
-import type { CredentialStore } from '@earendil-works/pi-ai';
 import { type McpServerConfig } from './config.ts';
 export declare const MCP_CREDENTIAL_PREFIX = "mcp:";
+export interface McpRecords {
+    mcp(server: string, name?: string): {
+        placeholder: string;
+    } | undefined;
+}
 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;
+export declare function resolveHeaders(server: string, config: McpServerConfig, records: McpRecords): Resolved;

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

@@ -1,6 +1,6 @@
-import type { CredentialStore } from '@earendil-works/pi-ai';
 import type { AuthProvider, McpFetch } from '@earendil-works/pi-mcp';
 import { authorizeMcp, McpOAuthAuthorizationRequiredError, type McpOAuthState } from '@earendil-works/pi-mcp/oauth';
+import type { PlainStore } from '../secrets/store.ts';
 import type { McpSignIn } from '../services.ts';
 import type { McpServerConfig } from './config.ts';
 type Provider = Parameters<typeof authorizeMcp>[0];
@@ -25,7 +25,7 @@ export declare class StoredOAuth implements Provider {
     #private;
     readonly redirectUrl: string;
     readonly clientMetadata: Provider['clientMetadata'];
-    constructor(server: OAuthServer, credentials: CredentialStore, redirectUrl: string);
+    constructor(server: OAuthServer, store: PlainStore, redirectUrl: string);
     get serverUrl(): string;
     load(): Promise<McpOAuthState>;
     update(change: (state: McpOAuthState) => McpOAuthState): Promise<void>;
@@ -47,6 +47,7 @@ export type { McpSignIn } from '../services.ts';
 export declare function beginSignIn(provider: StoredOAuth, server: OAuthServer, options: {
     fetch: McpFetch;
     resourceMetadataUrl?: URL;
+    register(tokenUrl: string): Promise<void>;
 }): Promise<McpSignIn>;
 export interface Callback {
     code?: string;

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

@@ -1,20 +1,35 @@
 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 type { McpServerSource } from '../secrets/endpoints.ts';
+import type { PlainStore } from '../secrets/store.ts';
 import { type McpAccounts } from './accounts.ts';
 import { McpCatalog } from './catalog.ts';
 import { type McpConfigProblem } from './config.ts';
 import { McpServerConnection } from './connection.ts';
+import { type McpRecords } from './credentials.ts';
 export declare const MCP_LOG_MAX_BYTES: number;
 export { configPath, logPath, shown } from './paths.ts';
+export interface McpVault {
+    records: McpRecords & {
+        refresh(context: Context): Promise<void>;
+        state: {
+            subscribe(listener: () => void): () => void;
+        };
+    };
+    fetch(server: string, base: typeof fetch): typeof fetch;
+    grant(server: string, base: typeof fetch): typeof fetch;
+    servers(list: readonly McpServerSource[]): Promise<void>;
+    token(server: string, url: string): Promise<void>;
+}
 export interface McpAttach {
     licks: Licks;
     env: ExecutionEnv;
     home: string;
     agentDir?: string;
-    credentials: CredentialStore;
+    store: PlainStore;
+    vault: McpVault;
     fetch: typeof fetch;
     version: string;
     reloadMs: number;
@@ -31,14 +46,13 @@ export interface ServerStatus {
 export type { McpAccounts } from './accounts.ts';
 export interface McpRuntime extends McpAccounts {
     status(): ServerStatus[];
-    secrets(): string[];
     reload(context: Context): Promise<void>;
     close(context: Context): Promise<void>;
 }
 export declare function problemLick(problem: McpConfigProblem, home: string, dir?: 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 logLine(server: string, params: unknown, 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;

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

@@ -11,6 +11,8 @@ export interface ModelsOptions {
     agents: Agents;
     settings: Pick<AgentSettings, 'state'>;
     catalog: Pick<Models, 'getProviders' | 'getModels'>;
+    locked?: () => boolean;
 }
+export declare const LOCKED_NOTE = "the vault is locked: unlock it to use these accounts";
 export declare function closest(wanted: string, ids: readonly string[], count?: number): string[];
 export declare function modelsCommand(options: ModelsOptions): (argv: readonly string[], caller: string | null, context: Context) => Promise<Answer>;

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

@@ -47,7 +47,6 @@ export interface MonitorOptions {
         name: string;
         uid: number;
     }[]>;
-    secrets?: () => readonly string[];
     now?: () => number;
     timers?: Timers;
     ttlMs?: number;

package/dist/types/monitor/redact.d.ts

@@ -1,5 +1,5 @@
 export declare const TEXT_MAX = 160;
 export declare function cut(text: string, max?: number): string;
-export declare function redacted(text: string, secrets: readonly string[]): string;
-export declare function commandLine(argv: readonly string[], secrets: readonly string[]): string;
+export declare function redacted(text: string): string;
+export declare function commandLine(argv: readonly string[]): string;
 export declare function program(argv: readonly string[]): string;

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

@@ -0,0 +1,5 @@
+import type { CredentialStore } from '@earendil-works/pi-ai';
+import type { VaultRecords } from './records.ts';
+export declare const KEYS_IN_VAULT = "model keys are kept in seven's vault: enter them in Settings \u203A Accounts";
+export type FieldsOf = (providerId: string) => Readonly<Record<string, string>> | undefined;
+export declare function vaultCredentials(records: Pick<VaultRecords, 'model' | 'state'>, env?: FieldsOf): CredentialStore;

package/dist/types/secrets/endpoints.d.ts

@@ -0,0 +1,27 @@
+import type { McpServerEntry, ModelEndpoint } from '@ai-ecoverse/slicc-vault';
+import type { ModelRoute } from './fetch.ts';
+import type { AgentRecord } from './records.ts';
+import type { Vault } from './vault.ts';
+export declare const BEDROCK_ENDPOINTS: string[];
+export declare function modelUrl(raw: string): boolean;
+export declare function mcpUrl(raw: string): boolean;
+export declare function pattern(base: string): RegExp;
+export interface ModelBases {
+    provider: string;
+    urls: readonly string[];
+}
+export declare function modelRoute(bases: () => readonly ModelBases[], records: () => readonly AgentRecord[]): ModelRoute;
+export declare function modelEndpoints(bases: readonly ModelBases[]): ModelEndpoint[];
+export interface McpServerSource {
+    server: string;
+    url: string;
+    names: readonly string[];
+}
+export declare function mcpEndpoints(servers: readonly McpServerSource[], tokens: ReadonlyMap<string, string>): McpServerEntry[];
+export interface Endpoints {
+    models(bases: readonly ModelBases[]): Promise<void>;
+    servers(servers: readonly McpServerSource[]): Promise<void>;
+    token(server: string, url: string): Promise<void>;
+    close(): void;
+}
+export declare function vaultEndpoints(vault: Pick<Vault, 'state' | 'connected' | 'endpoints'>): Endpoints;

package/dist/types/secrets/fetch.d.ts

@@ -0,0 +1,13 @@
+import type { OutgoingRequest } from '@ai-ecoverse/slicc-vault';
+import { type Vault } from './vault.ts';
+type Fetch = typeof fetch;
+type Port = Pick<Vault, 'connected' | 'needed' | 'model' | 'mcp' | 'refresh' | 'grant'>;
+export type ModelRoute = (request: Request) => string | null | undefined;
+export declare function absent(vault: Pick<Vault, 'connected' | 'needed'>): boolean;
+export declare function refusal(error: unknown): Response;
+export declare function safeError(error: unknown, original: OutgoingRequest, ready: OutgoingRequest): DOMException | TypeError;
+export declare function vaultFetch(vault: Port, inner: Fetch, route: ModelRoute): Fetch;
+export declare function mcpFetch(vault: Port, inner: Fetch, server: string): Fetch;
+export declare const NO_VAULT_SIGN_IN = "MCP sign-in needs seven's vault: update seven";
+export declare function grantFetch(vault: Port, server: string, base: Fetch): Fetch;
+export {};

package/dist/types/secrets/records.d.ts

@@ -0,0 +1,13 @@
+import type { AgentRecord } from '@ai-ecoverse/slicc-vault';
+import { type Context, type MutableReplicatedState } from '@earendil-works/chord';
+import type { Vault } from './vault.ts';
+export type { AgentRecord } from '@ai-ecoverse/slicc-vault';
+export interface VaultRecords {
+    readonly state: MutableReplicatedState<AgentRecord[]>;
+    refresh(context: Context): Promise<void>;
+    model(provider: string): AgentRecord | undefined;
+    mcp(server: string, name?: string): AgentRecord | undefined;
+    close(): void;
+}
+type Source = Pick<Vault, 'state' | 'records' | 'connected' | 'needed'>;
+export declare function vaultRecords(vault: Source): VaultRecords;

package/dist/types/secrets/store.d.ts

@@ -0,0 +1,7 @@
+import type { ExecutionEnv } from '@earendil-works/pi-durable/env';
+export interface PlainStore {
+    get(key: string): Promise<unknown>;
+    set(key: string, value: unknown): Promise<void>;
+}
+export declare function memoryStore(): PlainStore;
+export declare function fileStore(env: ExecutionEnv, path: string): PlainStore;

package/dist/types/secrets/vault.d.ts

@@ -1,3 +1,4 @@
+import type { AgentRecord, ErrorCode, McpServerEntry, ModelEndpoint, OAuthConfig, OutgoingRequest } from '@ai-ecoverse/slicc-vault';
 import { type MutableReplicatedState } from '@earendil-works/chord';
 import type { Scrub, Scrubbable, ScrubStream } from './scrub.ts';
 export type ScrubPair = {
@@ -14,14 +15,43 @@ export interface VaultState {
 }
 export declare const WAITING_MS = 2000;
 export declare const WAITING = "waiting for the vault";
+export declare class VaultRefusal extends Error {
+    readonly code: ErrorCode | undefined;
+    constructor(code: ErrorCode | undefined, message: string);
+}
+export type RefreshTarget = {
+    server: string;
+} | {
+    provider: string;
+};
+export interface Granted {
+    response: string | Uint8Array;
+    records: {
+        kind: string;
+        name: string;
+        placeholder: string;
+    }[];
+    expiresAt?: number;
+}
+export interface EndpointSet {
+    model: ModelEndpoint[];
+    mcp: McpServerEntry[];
+}
 export declare class Vault implements Scrub {
     #private;
     readonly state: MutableReplicatedState<VaultState>;
     constructor(now?: () => number);
     get needed(): boolean;
-    connect(port: MessagePort | undefined, scrub: unknown): void;
+    get connected(): boolean;
+    connect(port: MessagePort | undefined, scrub: unknown, locked?: unknown): void;
     ready(): Promise<void>;
     texts<T extends Scrubbable>(texts: readonly T[]): Promise<T[]>;
+    model(provider: string | undefined, request: OutgoingRequest): Promise<OutgoingRequest>;
+    mcp(server: string, request: OutgoingRequest): Promise<OutgoingRequest>;
+    records(): Promise<AgentRecord[]>;
+    grant(server: string, response: string | Uint8Array, oauth: OAuthConfig, name?: string): Promise<Granted>;
+    refresh(target: RefreshTarget, name?: string): Promise<string>;
+    endpoints(set: EndpointSet): Promise<void>;
     stream(): ScrubStream;
 }
 export declare function holdText(state: VaultState): string | undefined;

package/dist/types/services.d.ts

@@ -86,6 +86,7 @@ export interface AgentControl {
     monitorOpen(lease: string | null, resync: boolean, context: Context): Promise<MonitorLease>;
     monitorClose(lease: string, context: Context): Promise<void>;
     image(ref: ImageRef, context: Context): Promise<StoredImage>;
+    agentCommands(agentId: string, context: Context): Promise<Command[]>;
 }
 export interface ImageRef {
     entry: number;
@@ -238,6 +239,7 @@ export interface AgentTranscript {
     readonly agents: ReplicatedState<AgentsSummary>;
     readonly views: ReplicatedState<Record<string, ConversationView>>;
     readonly commands: ReplicatedState<Command[]>;
+    readonly privateRevision: ReplicatedState<PrivateRevision>;
     readonly sprinkles: ReplicatedState<Sprinkle[]>;
     readonly memories: ReplicatedState<MemoryEntry[]>;
     readonly memoryScopes: ReplicatedState<MemoryScope[]>;
@@ -246,6 +248,9 @@ export interface AgentTranscript {
     readonly monitor: ReplicatedState<MonitorFeed>;
     readonly vault: ReplicatedState<VaultState>;
 }
+export interface PrivateRevision {
+    revision: number;
+}
 export interface Command {
     name: string;
     description: string;
@@ -278,6 +283,13 @@ export interface AccountState {
     needs: 'cors-free-transport' | null;
     group?: 'providers' | 'mcp';
     secret?: 'api-key' | 'token';
+    store?: 'vault';
+    fields?: AccountField[];
+}
+export interface AccountField {
+    name: string;
+    label: string;
+    required?: boolean;
 }
 export interface BudgetState {
     provider: string;
@@ -301,7 +313,7 @@ export interface SettingsState {
 }
 export interface AgentSettings {
     readonly state: ReplicatedState<SettingsState>;
-    connect(providerId: string, secret: string, region: string | null, context: Context): Promise<void>;
+    connect(providerId: string, secret: string | null, fields: Record<string, string> | null, context: Context): Promise<void>;
     disconnect(providerId: string, context: Context): Promise<void>;
     signIn(providerId: string, context: Context): Promise<SignIn | McpSignIn | null>;
 }

package/dist/types/settings.d.ts

@@ -2,19 +2,34 @@ import type { CredentialStore, Provider } from '@earendil-works/pi-ai';
 import { type MutableModels } from '@earendil-works/pi-ai/models';
 import { type Budget } from './adobe.ts';
 import type { McpAccounts } from './mcp/index.ts';
-import type { AgentSettings } from './services.ts';
+import type { VaultRecords } from './secrets/records.ts';
+import type { PlainStore } from './secrets/store.ts';
+import type { AccountField, AgentSettings } from './services.ts';
 export declare const BEDROCK = "amazon-bedrock";
 export declare const DEFAULT_MODEL: {
     provider: string;
     modelId: string;
 };
 export declare const DEFAULT_REGIONS: Readonly<Record<string, string>>;
+export declare const ACCOUNT_FIELDS: Readonly<Record<string, readonly AccountField[]>>;
+export declare const SIGN_IN_NEEDS_VAULT = "Adobe sign-in needs seven's vault: update seven";
+export declare const KEY_NEEDS_VAULT = "API keys are kept in seven's vault: update seven";
 export declare function sliccProviders(version?: string): Provider[];
 export declare function withDefaultRegions(credentials: CredentialStore): CredentialStore;
 export declare function createSliccModels(credentials: CredentialStore, providers?: Provider<import("@earendil-works/pi-ai").Api>[]): MutableModels;
+export interface ProviderFields {
+    get(providerId: string): Readonly<Record<string, string>> | undefined;
+    env(providerId: string): Readonly<Record<string, string>> | undefined;
+    set(providerId: string, fields: Record<string, string> | undefined): Promise<void>;
+}
+export declare function providerFields(store: PlainStore, providers: readonly Provider[]): Promise<ProviderFields>;
 export declare function shown<T>(run: () => Promise<T>): Promise<T>;
 export type UsageReader = (token: string) => Promise<Budget | null>;
-export declare function createAgentSettings(models: MutableModels, credentials: CredentialStore, providers?: Provider<import("@earendil-works/pi-ai").Api>[], options?: {
+export interface SettingsSources {
+    records: VaultRecords;
+    fields: ProviderFields;
+}
+export declare function createAgentSettings(models: MutableModels, sources: SettingsSources, providers?: Provider<import("@earendil-works/pi-ai").Api>[], options?: {
     usage?: UsageReader;
     every?: number;
     mcp?: McpAccounts;

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

@@ -2,7 +2,7 @@ import { type Context, type ReplicatedState } from '@earendil-works/chord';
 import { type Extension, type Registry } from '@earendil-works/pi-durable';
 import type { ExecutionEnv } from '@earendil-works/pi-durable/env';
 import type { Licks } from '../licks/licks.ts';
-import type { Command } from '../services.ts';
+import type { Command, PrivateRevision } from '../services.ts';
 import { type Diagnostic, type Skill, type SkillRoot } from './skills.ts';
 import { type PromptTemplate } from './templates.ts';
 export declare const BUILTIN_SKILLS: string[];
@@ -16,6 +16,8 @@ export interface SkillsRuntime {
     skills(): readonly Skill[];
     dirs(): string[];
     templates(): readonly PromptTemplate[];
+    readonly privateRevision: ReplicatedState<PrivateRevision>;
+    commandsFor(agentId: string): Command[];
     expand(text: string, context: Context, conversationId?: number): Promise<string>;
     reload(context: Context): Promise<void>;
     close(context: Context): Promise<void>;
@@ -32,6 +34,7 @@ export interface SkillPeople {
     homes(): readonly string[];
     homeOf(conversationId: number | undefined): string | undefined;
     envOf(home: string): Promise<ExecutionEnv | undefined>;
+    homeOfAgent(agentId: string): string | undefined;
 }
 export declare function userRoots(homes: readonly string[]): SkillRoot[];
 export interface SkillsSetup {

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

@@ -34,7 +34,7 @@ export declare class AgentAdapter extends Emitter<AgentAdapterEvents> implements
     setModel(agentId: string, model: string): void;
     setThinking(agentId: string, level: Thinking): void;
     older(): Promise<readonly Message[]>;
-    commands(): readonly SlashCommand[];
+    commands(agentId?: string): readonly SlashCommand[];
     createScoop(parentId: string, name: string): Agent;
     drop(agentId: string): Promise<void>;
     createCone(name: string): Promise<Agent>;

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

@@ -3,9 +3,13 @@ import type { AgentSettings, SignIn } from '../services.ts';
 import type { AgentAdapter } from './agent-port.ts';
 import { Emitter } from './emitter.ts';
 export declare const SETTINGS_KEY = "slicc-agent.settings";
+export type Sealed = {
+    sealed: true;
+};
 export type Login = (providerId: string, signIn: () => Promise<SignIn | null>, options: {
     signal: AbortSignal;
-}) => Promise<string>;
+}) => Promise<string | Sealed>;
+export declare const SIGN_IN_NEEDS_VAULT = "Adobe sign-in needs seven's vault: update seven";
 export declare class SettingsAdapter extends Emitter<SettingsEvents> implements SettingsPort {
     #private;
     constructor(settings: AgentSettings, agent: AgentAdapter, storage: Pick<Storage, 'getItem' | 'setItem'> | null, login?: Login | null, mcp?: Login);
@@ -13,9 +17,7 @@ export declare class SettingsAdapter extends Emitter<SettingsEvents> implements
     update(patch: Partial<Settings>): void;
     models(): readonly ModelOption[];
     accounts(): readonly Account[];
-    connect(id: string, secret?: string, options?: {
-        region?: string;
-    }): Promise<void>;
+    connect(id: string, secret?: string, fields?: Record<string, string>): Promise<void>;
     cancel(id: string): void;
     disconnect(id: string): void;
 }

package/dist/types/titles/extension.d.ts

@@ -0,0 +1,19 @@
+import type { Context } from '@earendil-works/chord';
+import type { EntryRecord, Extension, Harness } from '@earendil-works/pi-durable';
+import type { Agents, ConeRecord } from '../agents.ts';
+export declare const TITLES = "slicc-titles";
+export declare const TITLE_TURNS: number[];
+export declare function trivial(text: string): boolean;
+export declare function titleDue(record: Pick<ConeRecord, 'titled'>, entries: readonly EntryRecord[], final?: boolean): number | undefined;
+export declare function cleanTitle(title: string | undefined): string | undefined;
+export type TitleFn = (transcript: string, model: string, context: Context) => Promise<string | undefined>;
+export interface TitlesAttach {
+    agents: () => Agents | undefined;
+    harness: () => Harness | undefined;
+    title: () => TitleFn | undefined;
+}
+export interface TitlesRuntime {
+    extension: Extension;
+    cancel(agentId: string): void;
+}
+export declare function titlesExtension(deps: TitlesAttach): TitlesRuntime;

package/dist/types/{freezer/title.d.ts → titles/generate.d.ts}

@@ -1,7 +1,11 @@
 import type { Context } from '@earendil-works/chord';
 import type { Models } from '@earendil-works/pi-ai/models';
+import type { EntryRecord } from '@earendil-works/pi-durable';
 import type { ExecutionEnv } from '@earendil-works/pi-durable/env';
 export declare const TITLE_PROMPT = "Give this chat a title of three to six words that says what it is about, in the language the user writes in. Answer with the title only, without quotes.";
+export declare const TRANSCRIPT_LENGTH = 4000;
 export declare function titlesOn(text: string | undefined): boolean;
 export declare function settingsText(env: Pick<ExecutionEnv, 'readTextFile'>, home: string, dir?: string): (context: Context) => Promise<string | undefined>;
+export declare function transcriptOf(entries: readonly EntryRecord[]): string;
+export declare function scrubTranscript(entries: readonly EntryRecord[]): Promise<string>;
 export declare function titler(models: Models, settings: (context: Context) => Promise<string | undefined>): (transcript: string, model: string, context: Context) => Promise<string | undefined>;