@theoremjs/studio 0.0.0-stage → 0.3.2

package/stream-lines.js

@@ -0,0 +1,27 @@
+/**
+ * A newline-delimited stream read a line at a time: `each` sees every line and sends on the ones
+ * it keeps, and `end` runs after the last.
+ */
+export function eachLine(each, end = () => { }) {
+    const decoder = new TextDecoder();
+    const encoder = new TextEncoder();
+    let partial = '';
+    const sender = (controller) => (line) => controller.enqueue(encoder.encode(`${line}\n`));
+    return new TransformStream({
+        transform(chunk, controller) {
+            const lines = (partial + decoder.decode(chunk, { stream: true })).split('\n');
+            partial = lines.pop() ?? '';
+            for (const line of lines)
+                if (line)
+                    each(line, sender(controller));
+        },
+        flush(controller) {
+            const rest = partial + decoder.decode();
+            if (rest)
+                each(rest, sender(controller));
+            end(sender(controller));
+        },
+    });
+}
+/** The content type of a run's stream. */
+export const NDJSON = 'application/x-ndjson';

package/stub.d.ts

@@ -0,0 +1,6 @@
+export declare function stubOutputFromSchema(schema: Record<string, unknown>): Record<string, unknown>;
+/**
+ * An input for testing a tool's connection: a demo tool's known-good one, else one built from
+ * `inputJson`. Undefined when the schema doesn't parse.
+ */
+export declare function sampleToolInput(toolName: string, inputJson: string): Record<string, unknown> | undefined;

package/stub.js

@@ -0,0 +1,33 @@
+import { demoHttpSampleInput } from "./concierge-demo.js";
+import { parseJsonSchema, sampleFromJsonSchema } from "./tool-schema.js";
+export function stubOutputFromSchema(schema) {
+    const stub = {};
+    const props = (schema.properties ?? {});
+    for (const [key, prop] of Object.entries(props)) {
+        const t = prop.type;
+        if (t === 'number' || t === 'integer')
+            stub[key] = 0;
+        else if (t === 'boolean')
+            stub[key] = false;
+        else if (t === 'array')
+            stub[key] = [];
+        else if (t === 'object')
+            stub[key] = {};
+        else
+            stub[key] = `studio:${key}`;
+    }
+    if (!Object.keys(stub).length)
+        stub.result = 'studio stub';
+    return stub;
+}
+/**
+ * An input for testing a tool's connection: a demo tool's known-good one, else one built from
+ * `inputJson`. Undefined when the schema doesn't parse.
+ */
+export function sampleToolInput(toolName, inputJson) {
+    const demo = demoHttpSampleInput(toolName.trim());
+    if (demo)
+        return demo;
+    const parsed = parseJsonSchema(inputJson, 'Input');
+    return parsed.ok ? sampleFromJsonSchema(parsed.schema) : undefined;
+}

package/surface.d.ts

@@ -0,0 +1,53 @@
+/**
+ * The studio as a surface: the draft's sections as nodes an agent can look at and set, its
+ * key slots as secret nodes it can point at and test, and the page's own actions (a new agent,
+ * a try in the preview, launch, export). The page supplies a host; the runtime does the rest.
+ */
+import type { TranscriptBlock } from '@theoremjs/agents/interface';
+import { type Surface, type SurfaceAuthor } from '@theoremjs/agents/surface';
+import { type StudioDraft } from './draft.ts';
+import type { StudioRunsOn } from './lent-keys.ts';
+export type StudioExportFormat = 'zip' | 'copy' | 'llm';
+/** One change to the draft: the top-level draft keys it touched, and who made it. */
+export interface StudioDraftChange {
+    revision: number;
+    by: SurfaceAuthor;
+    sections: readonly string[];
+}
+/** What the surface needs from the page; the route supplies it, a test fakes it. */
+export interface StudioSurfaceHost {
+    getDraft(): StudioDraft;
+    getRevision(): number;
+    /** What the page runs on, and on lent keys the keys it is held to. */
+    getRunsOn(): StudioRunsOn;
+    /**
+     * Replaces the draft as the agent's edit: the revision moves, and the person's undo stays.
+     * Returns what the person is being asked when the edit waits for their answer: it is not made.
+     */
+    update(next: StudioDraft): string | undefined;
+    /** A whole new agent: draft, selection, and conversation start over, with an Undo. */
+    replaceDraft(next: StudioDraft, message: string): void;
+    /** Selects a section in the editor, focusing one field when named. */
+    select(nodeId: string, field?: string): void;
+    changesSince(revision: number): readonly StudioDraftChange[];
+    subscribe(listener: () => void): () => void;
+    /** The key in a vault slot, `''` when empty. Read per answer and never kept. */
+    key(slot: string): string;
+    /** Opens the keys panel, on one slot when named. */
+    openKeys(slot?: string): void;
+    /** Tries the key in a slot against its provider; what it found, with no key in it. */
+    testKey?(slot: string): Promise<unknown>;
+    /** The credential typed into a tool's test, `''` when none. In memory only, never saved. */
+    toolCredential?(key: string): string;
+    /** Calls a custom tool once with sample input (and its test credential); what came back. */
+    testTool?(key: string, input?: unknown): Promise<unknown>;
+    /** Sends into the preview and waits for the reply; `null` when it can't take a message. */
+    send(text: string): Promise<{
+        blocks: readonly TranscriptBlock[];
+    } | null>;
+    newConversation(): void;
+    launch(): void;
+    exportAgent(format: StudioExportFormat): Promise<boolean>;
+}
+/** The studio's surface, over a host the page (or a test) provides. */
+export declare function studioSurface(host: StudioSurfaceHost): Surface;