@kelloggt/dsh-program-agents 0.0.0-stage → 0.1.1

package/dist/conversations.d.ts

@@ -0,0 +1,92 @@
+import type { ModelSelection } from './models.js';
+import type { JsonValue } from './types.js';
+import type { SessionFollowFrame, SessionPage } from '@deepseek-ai/dsh-api-session-controller/types';
+export type { SessionFollowFrame, SessionPage } from '@deepseek-ai/dsh-api-session-controller/types';
+export type { ModelSelection } from './models.js';
+/** A real, continuable DSH child, privately bound to this parent + program. */
+export interface ConversationOpenOptions {
+    name: string;
+    instructions?: string;
+    /** Creation-time route or a declared program model slot. Existing routes are immutable. */
+    model?: ModelSelection | string;
+}
+export interface ConversationInfo {
+    id: string;
+    name: string;
+    model?: ModelSelection;
+}
+export interface ConversationMessage {
+    text: string;
+    /** App-owned data, delivered as untrusted context on this exact prompt. */
+    context?: {
+        revision?: string | number;
+        state: JsonValue;
+    };
+}
+export interface ConversationReceipt {
+    requestId: string;
+    messageId: string;
+}
+export interface ConversationHistoryOptions {
+    /** Inclusive durable cut from the opening native snapshot; -1 means empty. */
+    throughSeq: number;
+    beforeSeq?: number;
+    maxMessages?: number;
+}
+export interface ConversationEventsOptions {
+    signal?: AbortSignal;
+    maxMessages?: number;
+}
+export interface ConversationSendOptions {
+    signal?: AbortSignal;
+    requestId?: string;
+    /** Queue owns a separate turn. Steering joins the nearest active step. */
+    mode?: 'queue' | 'steer';
+}
+/** Native history/stream vocabulary, plus the accepted prompt's durable identity. */
+export type ConversationFrame = SessionFollowFrame | ({
+    type: 'receipt';
+} & ConversationReceipt);
+export interface ConversationHandle extends ConversationInfo {
+    history(options: ConversationHistoryOptions, callOptions?: {
+        signal?: AbortSignal;
+        timeoutMs?: number;
+    }): Promise<SessionPage>;
+    /** Reconnection starts with a fresh native snapshot, not token replay. */
+    events(options?: ConversationEventsOptions): AsyncIterable<SessionFollowFrame>;
+    send(message: ConversationMessage, options?: ConversationSendOptions): Promise<ConversationReceipt>;
+    /** Subscribe before queueing; ends at this accepted message's native turn/end. */
+    ask(message: ConversationMessage, options?: Omit<ConversationSendOptions, 'mode'>): AsyncIterable<ConversationFrame>;
+    /** Requests cancellation; pending work survives and external effects are not undone. */
+    interrupt(options?: {
+        signal?: AbortSignal;
+        timeoutMs?: number;
+    }): Promise<{
+        accepted: true;
+    }>;
+}
+export interface ProgramConversations {
+    open(options: ConversationOpenOptions, callOptions?: {
+        signal?: AbortSignal;
+        timeoutMs?: number;
+    }): Promise<ConversationHandle>;
+    get(id: string, options?: {
+        signal?: AbortSignal;
+        timeoutMs?: number;
+    }): Promise<ConversationHandle | null>;
+    list(options?: {
+        signal?: AbortSignal;
+        timeoutMs?: number;
+    }): Promise<ConversationInfo[]>;
+}
+export declare const CONVERSATION_LIMITS: Readonly<{
+    bindings: 1024;
+    perProgram: 64;
+    activeStreams: 32;
+    streamsPerProgram: 4;
+    frameBytes: number;
+    messageBytes: number;
+    contextBytes: number;
+    defaultMessages: 20;
+    maxMessages: 100;
+}>;

package/dist/conversations.js

@@ -0,0 +1,6 @@
+export const CONVERSATION_LIMITS = Object.freeze({
+    bindings: 1024, perProgram: 64, activeStreams: 32, streamsPerProgram: 4,
+    frameBytes: 512 * 1024, messageBytes: 48 * 1024, contextBytes: 16 * 1024,
+    defaultMessages: 20, maxMessages: 100,
+});
+//# sourceMappingURL=conversations.js.map

package/dist/conversations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversations.js","sourceRoot":"","sources":["../src/conversations.ts"],"names":[],"mappings":"AAmDA,MAAM,CAAC,MAAM,mBAAmB,GAAG,MAAM,CAAC,MAAM,CAAC;IAC/C,QAAQ,EAAE,IAAI,EAAE,UAAU,EAAE,EAAE,EAAE,aAAa,EAAE,EAAE,EAAE,iBAAiB,EAAE,CAAC;IACvE,UAAU,EAAE,GAAG,GAAG,IAAI,EAAE,YAAY,EAAE,EAAE,GAAG,IAAI,EAAE,YAAY,EAAE,EAAE,GAAG,IAAI;IACxE,eAAe,EAAE,EAAE,EAAE,WAAW,EAAE,GAAG;CACtC,CAAC,CAAC"}

package/dist/endpoints.d.ts

@@ -0,0 +1,48 @@
+/** Persist recipes, never evaluated JavaScript or a previous process's port. */
+export interface ProgramEndpointDefinition {
+    port: 'dynamic' | number;
+}
+export interface EndpointNetworking {
+    /** Trusted harness setting; program metadata cannot expose a new interface. */
+    bindHost?: string;
+    /** Browser hostname by default, or an explicit reachable DNS/IP hostname. */
+    publicHost?: string;
+    /** Direct app protocol, not necessarily the DSH browser's protocol. Default http. */
+    protocol?: 'http' | 'https';
+}
+export type ProgramUrlDefinition = {
+    id: string;
+    title: string;
+    type: 'ui' | 'api' | 'docs';
+    docs?: string;
+} & (
+/** Legacy absolute URL / informational docs path. Exclusive with endpoint+path. */
+{
+    url: string;
+    endpoint?: never;
+    path?: never;
+} | {
+    url?: never;
+    endpoint: string;
+    path?: string;
+});
+export interface ResolvedEndpointAddress {
+    endpoint: string;
+    host: string;
+    protocol: 'http' | 'https';
+    port: number;
+    path: string;
+}
+export interface ProgramEndpointBinding {
+    id: string;
+    bindHost: string;
+    requestedPort: number;
+    port?: number;
+    publicHost: string;
+    protocol: 'http' | 'https';
+}
+export declare function endpointName(value: unknown): value is string;
+export declare function normalizeEndpointPath(value: unknown): string;
+export declare function normalizeHostname(value: unknown): string;
+/** Browser-safe; caller supplies browser hostname explicitly for deterministic tests. */
+export declare function endpointUrl(address: ResolvedEndpointAddress, browserHostname?: string): string | undefined;

package/dist/endpoints.js

@@ -0,0 +1,43 @@
+const controls = /[\u0000-\u0020\u007f\\]/;
+export function endpointName(value) { return typeof value === 'string' && /^[A-Za-z][A-Za-z0-9_-]{0,63}$/.test(value); }
+export function normalizeEndpointPath(value) {
+    if (value === undefined)
+        return '/';
+    if (typeof value !== 'string' || !value.startsWith('/') || value.startsWith('//') || value.length > 4096 || controls.test(value) || /%(?:0[0-9a-f]|1[0-9a-f]|7f|5c)/i.test(value))
+        throw Error('Endpoint path must be a bounded absolute path, not a URL or authority');
+    const u = new URL(value, 'http://endpoint.invalid');
+    if (u.origin !== 'http://endpoint.invalid')
+        throw Error('Invalid endpoint path');
+    return u.pathname + u.search + u.hash;
+}
+export function normalizeHostname(value) {
+    if (typeof value !== 'string' || !value || value.length > 253 || controls.test(value) || /[/?#@%]/.test(value))
+        throw Error('Invalid endpoint hostname');
+    const bracketed = value.includes(':') && !value.startsWith('[') ? '[' + value + ']' : value;
+    let u;
+    try {
+        u = new URL('http://' + bracketed + '/');
+    }
+    catch {
+        throw Error('Invalid endpoint hostname');
+    }
+    if (u.port || u.username || u.password || u.pathname !== '/' || !u.hostname)
+        throw Error('Hostname must not include a scheme, port or credentials');
+    return u.hostname;
+}
+/** Browser-safe; caller supplies browser hostname explicitly for deterministic tests. */
+export function endpointUrl(address, browserHostname) {
+    try {
+        if (!address || !endpointName(address.endpoint) || !['http', 'https'].includes(address.protocol) || !Number.isSafeInteger(address.port) || address.port < 1 || address.port > 65535)
+            return undefined;
+        const host = normalizeHostname(address.host === 'browser' ? browserHostname : address.host);
+        if (['0.0.0.0', '[::]', 'browser'].includes(host))
+            return undefined;
+        const path = normalizeEndpointPath(address.path);
+        return new URL(`${address.protocol}://${host}:${address.port}${path}`).href;
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=endpoints.js.map

package/dist/endpoints.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"endpoints.js","sourceRoot":"","sources":["../src/endpoints.ts"],"names":[],"mappings":"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"}

package/dist/examples/dashboard.js

@@ -0,0 +1,42 @@
+import { createServer } from "node:http";
+async function main(ctx) {
+  let processed = 0;
+  let lastInput = null;
+  const server = createServer((req, res) => {
+    if (req.url !== "/") {
+      res.writeHead(404);
+      res.end();
+      return;
+    }
+    const data = JSON.stringify({ processed, lastInput, generation: ctx.generation }).replaceAll("<", "\\u003c");
+    res.writeHead(200, { "Content-Type": "text/html; charset=utf-8", "Content-Security-Policy": "default-src 'none'; script-src 'unsafe-inline'; style-src 'unsafe-inline'", "Cache-Control": "no-store" });
+    res.end(`<!doctype html><title>Program dashboard</title><style>body{font:18px system-ui;max-width:700px;margin:3rem auto;background:#15171c;color:#eee}pre{white-space:pre-wrap}</style><h1>Supervised program</h1><p>Reload to see the latest state. Send JSON from DSH.</p><pre id="data"></pre><script>document.getElementById('data').textContent=JSON.stringify(${data},null,2)</script>`);
+  });
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => resolve());
+  });
+  const address = server.address();
+  if (!address || typeof address === "string") throw new Error("No server address");
+  await ctx.resources.publish({ id: "dashboard", title: "Program dashboard", url: `http://127.0.0.1:${address.port}/` });
+  await ctx.status("running", "Dashboard ready; waiting for JSON input");
+  try {
+    for await (const message of ctx.inbox) {
+      lastInput = message.body;
+      processed++;
+      if (message.body && typeof message.body === "object" && !Array.isArray(message.body) && message.body.action === "help") {
+        await ctx.status("blocked", "Waiting for supervisor advice");
+        await ctx.parent.send({ type: "needs_help", reason: "Example explicit escalation", processed });
+      } else {
+        await ctx.status("running", `Processed ${processed} message(s)`);
+        console.log(`Processed message ${processed}`);
+      }
+    }
+  } finally {
+    await new Promise((resolve) => server.close(() => resolve()));
+  }
+  return { processed };
+}
+export {
+  main as default
+};

package/dist/examples/dynamic-server.js

@@ -0,0 +1,27 @@
+import { createServer } from "node:http";
+import { connectProgram, installGlobalErrorHandlers } from "@kelloggt/dsh-program-agents/app";
+const app = connectProgram();
+installGlobalErrorHandlers(app.logger);
+const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+const server = createServer((req, res) => {
+  if (req.url === "/api/status") {
+    res.writeHead(200, { "content-type": "application/json", "cache-control": "no-store" });
+    res.end(JSON.stringify({ pid: process.pid, startedAt, message: "Harness endpoint is bound and advertised" }));
+    return;
+  }
+  if (req.url !== "/") {
+    res.writeHead(404);
+    res.end();
+    return;
+  }
+  res.writeHead(200, { "content-type": "text/html; charset=utf-8", "cache-control": "no-store", "content-security-policy": "default-src 'none'; style-src 'unsafe-inline'" });
+  res.end('<!doctype html><title>Dynamic endpoint demo</title><style>body{font:18px system-ui;max-width:700px;margin:4rem auto}a{color:#368}</style><h1>Dynamic endpoint demo</h1><p>This server uses a harness-supplied interface and an OS-assigned port. Restarting resolves the endpoint again.</p><a href="/api/status">API status</a>');
+});
+const listener = await app.endpoints.listen("web", server);
+app.logger.info("Endpoint ready", { port: listener.port, bind_host: listener.host, local_url: listener.localUrl }, { log_type: "com.example.endpoint.ready.v1" });
+let closing = false;
+for (const signal of ["SIGINT", "SIGTERM"]) process.on(signal, () => {
+  if (closing) return;
+  closing = true;
+  void listener.close().finally(() => app.logger.close()).finally(() => process.exit(0));
+});

package/dist/examples/inbox-worker.js

@@ -0,0 +1,22 @@
+import { connectProgram, installGlobalErrorHandlers } from "@kelloggt/dsh-program-agents/app";
+const program = connectProgram({ logger: { logsPath: "./logs", stdout: true, private: true } });
+installGlobalErrorHandlers(program.logger);
+program.logger.info("Inbox worker ready", { pid: process.pid }, { log_type: "com.example.inbox.ready.v1" });
+const abort = new AbortController();
+for (const signal of ["SIGINT", "SIGTERM"]) process.on(signal, () => abort.abort());
+try {
+  while (!abort.signal.aborted) {
+    await program.inbox.receive({ waitMs: 25e3, leaseMs: 6e4, signal: abort.signal }, async (message, { signal }) => {
+      signal.throwIfAborted();
+      program.logger.info("Received application work", { message_id: message.id }, { log_type: "com.example.inbox.processed.v1", operation_id: message.correlationId ?? message.id });
+      return "processed";
+    });
+  }
+} catch (error) {
+  if (!abort.signal.aborted) {
+    program.logger.error("Inbox worker failed", {}, { error });
+    throw error;
+  }
+} finally {
+  await program.logger.close();
+}

package/dist/examples/model-slots.js

@@ -0,0 +1,19 @@
+import { connectProgram, installGlobalErrorHandlers } from "@kelloggt/dsh-program-agents/app";
+const dsh = connectProgram({ logger: { logsPath: "./logs/model-slots", stdout: true, private: true } });
+installGlobalErrorHandlers(dsh.logger);
+await dsh.models.declare({
+  "smart-model": { description: "Difficult judgments and multi-step planning.", default: { provider: "codex", model: "gpt-6.1-sol", reasoningEffort: "xhigh" } },
+  "cheap-local": { description: "Private, low-cost classification and short summaries.", default: { provider: "local-mlx", model: "Qwen3.8-27B-4bit" } }
+});
+dsh.logger.info("Model slots ready; configure selections with the program Models button", {}, { log_type: "com.example.models.ready.v1" });
+const stop = new AbortController();
+for (const signal of ["SIGINT", "SIGTERM"]) process.on(signal, () => stop.abort());
+await new Promise((resolve) => {
+  const timer = setInterval(() => {
+  }, 6e4);
+  stop.signal.addEventListener("abort", () => {
+    clearInterval(timer);
+    resolve();
+  }, { once: true });
+});
+await dsh.logger.close();

package/dist/examples/standalone-supervisor.js

@@ -0,0 +1,20 @@
+import { resolve } from "node:path";
+import { ProgramSupervisor } from "@kelloggt/dsh-program-agents/runtime";
+const supervisor = new ProgramSupervisor({
+  programs: { dashboard: { entry: resolve("examples/dashboard.ts"), allowedCapabilities: [] } },
+  onParentMessage: async (_owner, body) => {
+    console.log("Program asks parent:", body);
+  }
+});
+const run = await supervisor.start({ program: "dashboard", ownerId: "demo", input: null });
+console.log("Started", run.id, "\u2014 press Ctrl+C to stop.");
+const timer = setInterval(() => {
+  const r = supervisor.get(run.id, "demo");
+  for (const resource of r.resources) if (resource.available) console.log("Dashboard:", resource.url);
+}, 3e3);
+timer.unref();
+await supervisor.send(run.id, "demo", { hello: "world" });
+process.once("SIGINT", () => {
+  clearInterval(timer);
+  void supervisor.dispose().then(() => process.exit(0));
+});

package/dist/host/adapter.d.ts

@@ -0,0 +1,195 @@
+import { AuditJournal } from './audit.js';
+import { ProgramCatalog } from './catalog.js';
+import { ProgramEvents } from './events.js';
+import { AppBridgeServer } from '../app/server.js';
+import { MessageStore } from '../app/mailbox.js';
+import { SupervisorRouter } from './agents.js';
+import { SupervisionPolicies } from './policies.js';
+import { ProgramOperations } from './operations.js';
+import { RequestStore } from './requests.js';
+import { ProgramModelStore } from './models.js';
+import { ConversationService } from './conversations.js';
+import type { ProgramDefinition } from '../types.js';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { Context } from '@deepseek-ai/cordis';
+import type { PluginConfig } from './contracts.js';
+import { CapabilityRegistry, ProgramSupervisor } from '../runtime/index.js';
+import type { JsonValue, ProgramSnapshot } from '../types.js';
+declare module '@deepseek-ai/dsh-llm' {
+    interface MessageSourceMap {
+        'program-agent': {
+            kind: 'program-agent';
+            runId: string;
+            generation: number;
+        };
+    }
+}
+/** No stale ToolRunContext is retained: every operation belongs to this run. */
+export declare class DshProgramAdapter {
+    readonly ctx: Context;
+    readonly config: PluginConfig;
+    readonly capabilities: CapabilityRegistry;
+    readonly supervisor: ProgramSupervisor;
+    readonly journal: AuditJournal;
+    private owners;
+    private lifecycle;
+    private notices;
+    private revoking;
+    private uiStarts;
+    readonly catalog: ProgramCatalog;
+    readonly events: ProgramEvents;
+    readonly bridge: AppBridgeServer;
+    readonly mailbox: MessageStore;
+    readonly requests: RequestStore;
+    readonly modelSlots: ProgramModelStore;
+    readonly conversations: ConversationService;
+    private requestDispatches;
+    readonly router: SupervisorRouter;
+    readonly policies: SupervisionPolicies;
+    readonly operations: ProgramOperations;
+    private disposed;
+    private resumed;
+    private servicesReady;
+    constructor(ctx: Context, config: PluginConfig);
+    private disposePartial;
+    definition(ownerId: string, program: string): ProgramDefinition | undefined;
+    eligible(ownerId: string): boolean;
+    resolveOwner(ownerId: string): Promise<Agent>;
+    executeAgentTool(agent: Agent, name: string, args: JsonValue, signal: AbortSignal): Promise<unknown>;
+    restoreStartup(): Promise<void>;
+    sessionCreated(agent: Agent): Promise<void>;
+    stopSession(ownerId: string): Promise<void>;
+    stop(id: string, ownerId: string): Promise<ProgramSnapshot>;
+    restart(id: string, ownerId: string): Promise<ProgramSnapshot>;
+    appCall(run: ProgramSnapshot, method: string, input: JsonValue, signal: AbortSignal): Promise<JsonValue>;
+    private appStream;
+    modelConfiguration(ownerId: string, program: string): Promise<{
+        slots: import("../models.js").ModelSlotView[];
+        catalog: any;
+    }>;
+    setModelConfiguration(ownerId: string, program: string, slot: string, selection: unknown, revision: number, signal: AbortSignal): Promise<import("../models.js").ModelSlotView>;
+    private resolveModelSelection;
+    private requestView;
+    private askAgent;
+    replyToRequest(sender: Agent, parentId: string, program: string, requestId: string, body: JsonValue): Promise<import("./requests.js").ResponseReceipt>;
+    private dispatchTool;
+    sendInbox(sender: Agent, parentId: string, program: string, body: JsonValue, correlationId?: string): Promise<import("../app/mailbox.js").MessageReceipt>;
+    dispose(): Promise<void>;
+    view(ownerId: string): {
+        runs: {
+            logs: never[];
+            messages: never[];
+            id: string;
+            generation: number;
+            program: string;
+            ownerId: string;
+            label: string;
+            name?: string;
+            description?: string;
+            command?: string[];
+            logsPath?: string;
+            supervision?: import("../supervision.js").SupervisionSettings;
+            state: import("../types.js").ProgramState;
+            status?: string;
+            pid?: number;
+            startedAt: string;
+            endedAt?: string;
+            error?: string;
+            resources: import("../types.js").ProgramResource[];
+            endpoints?: import("../endpoints.js").ProgramEndpointBinding[];
+        }[];
+        programs: {
+            hasModelSlots: boolean;
+            modelRevision: string;
+            program: string;
+            name: string;
+            description: string;
+            command: string[];
+            urls: import("../types.js").ProgramResource[];
+            endpoints?: Record<string, import("../endpoints.js").ProgramEndpointDefinition>;
+            logsPath?: string;
+            supervision?: import("../supervision.js").SupervisionSettings;
+        }[];
+    };
+    bindOwner(agent: Agent): Promise<Agent>;
+    register(agent: Agent, input: unknown, signal?: AbortSignal): Promise<import("../types.js").ProgramDescriptor>;
+    /** UI start traverses the exact parent's public tool policy, not a shell escape. */
+    startFromUi(ownerId: string, program: string, signal: AbortSignal): Promise<{
+        runs: {
+            logs: never[];
+            messages: never[];
+            id: string;
+            generation: number;
+            program: string;
+            ownerId: string;
+            label: string;
+            name?: string;
+            description?: string;
+            command?: string[];
+            logsPath?: string;
+            supervision?: import("../supervision.js").SupervisionSettings;
+            state: import("../types.js").ProgramState;
+            status?: string;
+            pid?: number;
+            startedAt: string;
+            endedAt?: string;
+            error?: string;
+            resources: import("../types.js").ProgramResource[];
+            endpoints?: import("../endpoints.js").ProgramEndpointBinding[];
+        }[];
+        programs: {
+            hasModelSlots: boolean;
+            modelRevision: string;
+            program: string;
+            name: string;
+            description: string;
+            command: string[];
+            urls: import("../types.js").ProgramResource[];
+            endpoints?: Record<string, import("../endpoints.js").ProgramEndpointDefinition>;
+            logsPath?: string;
+            supervision?: import("../supervision.js").SupervisionSettings;
+        }[];
+    }>;
+    controlFromUi(agent: Agent, action: 'start' | 'stop' | 'restart', args: JsonValue, signal: AbortSignal): Promise<{
+        runs: {
+            logs: never[];
+            messages: never[];
+            id: string;
+            generation: number;
+            program: string;
+            ownerId: string;
+            label: string;
+            name?: string;
+            description?: string;
+            command?: string[];
+            logsPath?: string;
+            supervision?: import("../supervision.js").SupervisionSettings;
+            state: import("../types.js").ProgramState;
+            status?: string;
+            pid?: number;
+            startedAt: string;
+            endedAt?: string;
+            error?: string;
+            resources: import("../types.js").ProgramResource[];
+            endpoints?: import("../endpoints.js").ProgramEndpointBinding[];
+        }[];
+        programs: {
+            hasModelSlots: boolean;
+            modelRevision: string;
+            program: string;
+            name: string;
+            description: string;
+            command: string[];
+            urls: import("../types.js").ProgramResource[];
+            endpoints?: Record<string, import("../endpoints.js").ProgramEndpointDefinition>;
+            logsPath?: string;
+            supervision?: import("../supervision.js").SupervisionSettings;
+        }[];
+    }>;
+    owner(id: string): Agent;
+    start(agent: Agent, program: string, input?: JsonValue, label?: string, signal?: AbortSignal): Promise<ProgramSnapshot>;
+    ownerDisposed(agent: Agent): Promise<void>;
+    private audit;
+    private model;
+    private tool;
+}