@jigs.design/server 0.3.1 → 0.3.3

package/dist/chat.js

@@ -218,6 +218,7 @@ function createReplyParser(deps, history) {
 		};
 		if (error !== void 0) block.error = error;
 		if (compiled.ref !== null) block.ref = compiled.ref;
+		if (compiled.toolKeys !== null && compiled.toolKeys !== void 0) block.toolKeys = compiled.toolKeys;
 		return block;
 	};
 	const emit = (block) => {
@@ -615,15 +616,18 @@ async function* repairBlock(deps, block) {
 	else if (event.type === "done") {
 		const body = splitPragma(event.source).body;
 		deps.parser.remember(block.name, body);
+		const { toolKeys: _before, ...rest } = block;
 		const repaired = {
-			...block,
+			...rest,
 			diagnostics: event.diagnostics,
 			program: program ?? block.program,
 			source: event.source,
 			status: "done"
 		};
-		const { ref } = deps.session.checker.compile(body);
+		const compiled = deps.session.checker.compile(body);
+		const { ref } = compiled;
 		if (ref !== null) repaired.ref = ref;
+		if (compiled.toolKeys !== null) repaired.toolKeys = compiled.toolKeys;
 		if (result !== void 0) {
 			result.status = "done";
 			if (ref !== null) result.ref = ref;

package/dist/compile.js

@@ -4,6 +4,7 @@ import { inputDiagnostics } from "./inputs.js";
 import { outputDiagnostics } from "./outputs.js";
 import { splitPragma, versionDiagnostics } from "./pragma.js";
 import { compileJigs, compileLibrary, spanIn } from "@jigs.design/compiler";
+import { TOOL_RESULTS } from "@jigs.design/prompt";
 import { componentSchema } from "@jigs.design/host";
 import { PROGRAM_FORMAT } from "@jigs.design/protocol";
 //#region src/compile.ts
@@ -270,6 +271,7 @@ function createChecker(host) {
 		let ref = diagnostics.some((diagnostic) => diagnostic.severity === "error") ? null : refOf(result.program.tree, pages);
 		const define = ref === null ? void 0 : fullLibrary.get(ref.name);
 		if (ref !== null && (define === void 0 || pagePropsProblem(define, ref.props) !== null)) ref = null;
+		const procedures = procedureTable(host, [...own, ...reached.uses]);
 		return {
 			advise: (placement) => designChecks({
 				catalog: host.components,
@@ -282,10 +284,11 @@ function createChecker(host) {
 				components: Object.fromEntries(host.components.components.filter((component) => reached.tags.has(component.name)).map((component) => [component.name, componentSchema(component)])),
 				format: PROGRAM_FORMAT,
 				imageHosts: host.imageHosts,
-				procedures: procedureTable(host, [...own, ...reached.uses]),
+				procedures,
 				prose: result.output.constants
 			},
-			ref
+			ref,
+			toolKeys: !Object.hasOwn(procedures, TOOL_RESULTS) ? null : reached.uses.some((use) => use.name === TOOL_RESULTS) ? "all" : result.fields[TOOL_RESULTS] ?? []
 		};
 	};
 	const compile = (body) => compileWith(body, tagLibrary, tagFacts);

package/dist/core.js

@@ -7,6 +7,7 @@ import { confirmMessage, createConfirmer, memoryConfirmations } from "./confirm.
 import { processCompileCache, sha256 } from "./compile-cache.js";
 import { eventStream } from "./events.js";
 import { invalidationsOf } from "./invalidation.js";
+import { withToolResults } from "./tool-results.js";
 import { createModelServer } from "./model-server.js";
 import { systemPromptParts } from "@jigs.design/prompt";
 import { isCallPolicy } from "@jigs.design/host";
@@ -25,7 +26,17 @@ const COMPILER_PROBE = `{@body const [count, setCount] = useState(0)}
 **done**
 </if>`;
 /** What `resolvePage` must return, checked, since a plain-JavaScript one may not. */
-const savedPageSchema = z.object({ source: z.string() });
+const savedPageSchema = z.object({
+	data: z.record(z.string(), z.json()).optional(),
+	source: z.string()
+});
+/**
+* The most JSON a saved page's `data` may be, in characters, the order of
+* `MAX_CONTENT`: the app stored it, so past it the page is `INTERNAL`.
+*/
+const MAX_PAGE_DATA = 256e3;
+/** What a page without provided data carries: one object, shared and frozen. */
+const NO_DATA = Object.freeze({});
 /** The strict rule: an error or warning diagnostic throws. */
 function strictly(subject, compiled) {
 	const fatal = fatalDiagnostics(compiled.diagnostics);
@@ -115,17 +126,26 @@ function defineRun(procedures, handlers) {
 	return handlers;
 }
 function createJigsServer(options) {
-	const { host } = options;
+	const tools = options.toolResults === true;
+	const host = tools ? withToolResults(options.host) : options.host;
 	checkMarkdownElements(host.components);
 	for (const [name, procedure] of Object.entries(host.procedures)) if (procedure.kind !== "action" && procedure.kind !== "data" && !Object.hasOwn(options.run, name)) throw new Error(`createJigsServer has no run function for "${name}"`);
 	const confirmer = confirmerFor(options);
 	const checker = createChecker(host);
-	const promptOptions = (mode) => options.instructions === void 0 ? { mode } : {
+	const promptOptions = (mode) => options.instructions === void 0 ? {
+		mode,
+		toolResults: tools
+	} : {
 		instructions: options.instructions,
-		mode
+		mode,
+		toolResults: tools
 	};
-	const documentParts = systemPromptParts(host, promptOptions("document"));
+	const documentParts = systemPromptParts(options.host, {
+		...promptOptions("document"),
+		toolResults: false
+	});
 	const chatParts = systemPromptParts(host, promptOptions("chat"));
+	const toolParts = tools ? systemPromptParts(host, promptOptions("document")) : null;
 	const system = `${documentParts.stable}\n\n${documentParts.variable}`;
 	const chatSystem = `${chatParts.stable}\n\n${chatParts.variable}`;
 	const allowedOrigins = new Set((options.allowedOrigins ?? []).map((entry) => originOf(entry)));
@@ -365,11 +385,13 @@ function createJigsServer(options) {
 		const stored = splitPragma(source);
 		const compiled = checker.compile(stored.body);
 		const prefix = source.slice(0, source.length - stored.body.length);
-		return {
+		const result = {
 			advice: belowPrefix(compiled.advise(placement), prefix),
 			diagnostics: [...versionDiagnostics(stored.versions, host.components.version), ...belowPrefix(compiled.diagnostics, prefix)],
 			program: compiled.program
 		};
+		if (compiled.toolKeys !== null) result.toolKeys = compiled.toolKeys;
+		return result;
 	};
 	/**
 	* `compile` through the process's cache, keyed by what this server
@@ -402,11 +424,13 @@ function createJigsServer(options) {
 		const subject = `Jig "${entry.name}"`;
 		if (entry.kind === "document") startupPages.set(entry.name, {
 			...strictly(subject, compileStored(entry.source)),
+			data: NO_DATA,
 			origin: "shipped",
 			source: entry.source
 		});
 		else if (!checker.needsProps(entry.name)) startupPages.set(entry.name, {
 			...strictly(subject, compileDefine(entry.name, {})),
+			data: NO_DATA,
 			origin: "shipped",
 			source: checker.pageBody(entry.name, {})
 		});
@@ -420,6 +444,7 @@ function createJigsServer(options) {
 		const compiled = await cached("page", body, () => compileDefine(entry.name, props));
 		return {
 			...strictly(`Page "${entry.name}"`, compiled),
+			data: NO_DATA,
 			origin: "shipped",
 			source: body
 		};
@@ -431,7 +456,10 @@ function createJigsServer(options) {
 		});
 		return new JigsError("INTERNAL", INTERNAL_MESSAGE);
 	};
-	/** The source `resolvePage` finds for `call.ctx`, checked; null when it finds none. */
+	/**
+	* The page `resolvePage` finds for `call.ctx`, checked: its source and
+	* the data it keeps (empty without). Null when it finds none.
+	*/
 	const savedSource = async (name, props, lookup) => {
 		if (options.resolvePage === void 0) return null;
 		let found;
@@ -446,21 +474,26 @@ function createJigsServer(options) {
 		}
 		if (found === null) return null;
 		const checked = savedPageSchema.safeParse(found);
-		if (!checked.success) throw internal(/* @__PURE__ */ new Error(`resolvePage returned ${String(found)} for "${name}"; return { source } or null`), name);
-		const source = checked.data.source;
-		if (source.length > 2e5) throw internal(/* @__PURE__ */ new Error(`The source resolvePage returned for "${name}" is longer than ${MAX_CONTENT} characters`), name);
+		if (!checked.success) throw internal(/* @__PURE__ */ new Error(`resolvePage returned ${String(found)} for "${name}"; return { source, data? } or null`), name);
+		const { data } = checked.data;
+		if (checked.data.source.length > 2e5) throw internal(/* @__PURE__ */ new Error(`The source resolvePage returned for "${name}" is longer than ${MAX_CONTENT} characters`), name);
+		if (data !== void 0 && JSON.stringify(data).length > MAX_PAGE_DATA) throw internal(/* @__PURE__ */ new Error(`The data resolvePage returned for "${name}" is longer than ${MAX_PAGE_DATA} characters of JSON`), name);
 		noProps(name, props);
-		return source;
+		return {
+			data: data ?? NO_DATA,
+			source: checked.data.source
+		};
 	};
 	/** A page `resolvePage` finds for `call.ctx`, compiled leniently unless `strict`. */
 	const savedPage = async (name, props, lookup) => {
-		const source = await savedSource(name, props, lookup);
-		if (source === null) return null;
-		const compiled = await compileCached(source);
+		const saved = await savedSource(name, props, lookup);
+		if (saved === null) return null;
+		const compiled = await compileCached(saved.source);
 		return {
 			...lookup.strict === true ? strictly(`Page "${name}"`, compiled) : compiled,
+			data: saved.data,
 			origin: "saved",
-			source
+			source: saved.source
 		};
 	};
 	const resolve = async (name, props = {}, lookup) => {
@@ -514,6 +547,7 @@ function createJigsServer(options) {
 		} else try {
 			const resolved = await page(name, props, context);
 			outcome = resolved === null ? { error: notFound } : {
+				data: resolved.data,
 				diagnostics: resolved.diagnostics,
 				program: resolved.program,
 				version
@@ -548,7 +582,10 @@ function createJigsServer(options) {
 	*/
 	const pageSource = async (name, props, context) => {
 		const entry = jigsByName.get(name);
-		if (entry === void 0) return savedSource(name, props, context);
+		if (entry === void 0) {
+			const saved = await savedSource(name, props, context);
+			return saved === null ? null : saved.source;
+		}
 		const shippedName = name;
 		if (!entry.page || !pageAllowed(context.ctx, shippedName, props)) return null;
 		if (entry.kind === "document") {
@@ -713,7 +750,11 @@ function createJigsServer(options) {
 			handlerDeps,
 			host,
 			onError,
-			prepareSession
+			prepareSession,
+			toolPrompt: toolParts === null ? null : {
+				system: `${toolParts.stable}\n\n${toolParts.variable}`,
+				systemPrefix: toolParts.stable
+			}
 		}, core, modelOptions)
 	};
 	return core;

package/dist/model-server.js

@@ -1,7 +1,9 @@
 import { INTERNAL_MESSAGE, JigsError, isJigsError } from "./errors.js";
+import { splitPragma } from "./pragma.js";
 import { createHandler, issuesText, parseBounded } from "./handler.js";
 import { MAX_CONTENT, runSession } from "./session.js";
 import { createReplyParser, repairBlock, streamChat } from "./chat.js";
+import { TOOL_RESULTS } from "@jigs.design/prompt";
 import { z } from "zod";
 //#region src/model-server.ts
 /**
@@ -54,6 +56,14 @@ function createModelServer(internals, core, options) {
 		system,
 		systemPrefix: core.promptPrefix("document")
 	};
+	const toolPrompt = internals.toolPrompt;
+	const toolSessionDeps = toolPrompt === null ? sessionDeps : {
+		...sessionDeps,
+		system: toolPrompt.system,
+		systemPrefix: toolPrompt.systemPrefix
+	};
+	/** A session's deps: the slot's prompt when its document reads `toolResults`. */
+	const depsFor = (turn) => toolPrompt !== null && turn.document !== null && Object.hasOwn(internals.checker.compile(splitPragma(turn.document).body).program.procedures, TOOL_RESULTS) ? toolSessionDeps : sessionDeps;
 	const chat = async (request, chatOptions) => {
 		const refused = internals.handlerDeps.http.refusal(request);
 		if (refused !== null) throw new JigsError(refused.code, refused.message);
@@ -98,7 +108,7 @@ function createModelServer(internals, core, options) {
 			parser,
 			prompt: input.data.prompt,
 			session: {
-				...sessionDeps,
+				...toolSessionDeps,
 				kind: "chat-repair",
 				maxRepairs: repairRounds
 			}
@@ -130,7 +140,7 @@ function createModelServer(internals, core, options) {
 			session: async (body, call) => {
 				const prepared = await prepareSession(body, call);
 				if ("error" in prepared) return prepared;
-				return { turn: (turnCall) => runSession(sessionDeps, prepared.turn, prepared.options, turnCall) };
+				return { turn: (turnCall) => runSession(depsFor(prepared.turn), prepared.turn, prepared.options, turnCall) };
 			}
 		}),
 		maxBodyBytes: core.maxBodyBytes,
@@ -146,7 +156,7 @@ function createModelServer(internals, core, options) {
 				};
 				return;
 			}
-			yield* runSession(sessionDeps, prepared.turn, prepared.options, context);
+			yield* runSession(depsFor(prepared.turn), prepared.turn, prepared.options, context);
 		},
 		version: core.version
 	};

package/dist/tool-results.js

@@ -0,0 +1,20 @@
+import { TOOL_RESULTS, toolResultsSlot } from "@jigs.design/prompt";
+//#region src/tool-results.ts
+/**
+* `host` with the `toolResults` slot added, for a server with
+* `toolResults: true`: the checker, the calls and the prompts that list it
+* see one more provided slot. Throws when the host already has a procedure
+* of that name.
+*/
+function withToolResults(host) {
+	if (Object.hasOwn(host.procedures, TOOL_RESULTS)) throw new Error(`The host has a procedure named "${TOOL_RESULTS}", which toolResults: true adds; rename it`);
+	return {
+		...host,
+		procedures: {
+			...host.procedures,
+			[TOOL_RESULTS]: toolResultsSlot
+		}
+	};
+}
+//#endregion
+export { withToolResults };

package/dist/types.d.ts

@@ -289,8 +289,15 @@ export interface ErrorInfo {
    */
   type: "call" | "chat" | "events" | "page" | "session";
 }
-/** A page `resolvePage` found: the source as the app stored it. */
+/** A page `resolvePage` found: the source as the app stored it, and what it reads. */
 export interface SavedPage {
+  /**
+   * Provided data the page is drawn with, by slot: what the app kept with
+   * it, such as the tool results a chat block had. Fixed to the page: it
+   * travels beside the program and is cached with it. Not parsed against
+   * the slots' schemas; `jigs.data` checks a value before it is stored.
+   */
+  data?: Readonly<Record<string, JsonValue>>;
   /** The source, with its pragma line when the app kept it. */
   source: string;
 }
@@ -298,6 +305,7 @@ export interface SavedPage {
  * Finds a page the host does not ship, by name, for the caller `ctx` names.
  * `null` is "no such page for this caller". Runs on every request for the
  * name; cache in it if the store is slow. Throw a `JigsError` to refuse.
+ * `data` is optional: the provided slots the page keeps, as JSON.
  */
 export type PageResolver<TContext> = (name: string, call: {
   ctx: TContext;
@@ -391,6 +399,18 @@ export interface JigsServerOptions<TProcedures extends Procedures, TCatalog exte
    * "confirm": the server refuses to start without it.
    */
   secret?: string;
+  /**
+   * Adds a provided slot, `toolResults`, for a chat whose agent calls
+   * tools: the page passes each block the results of the tools called
+   * before it, by tool name (`toolData` in `@jigs.design/ai-sdk/client`),
+   * and the block reads them with `useQuery("toolResults")` instead of the
+   * model copying them into its source. The chat prompt lists the slot and
+   * says how to read it, as do chat repairs and a session on a block's
+   * source; a plain session's prompt is unchanged. Fixed for the server's
+   * life, so the prompt's cached start never changes per turn. A host
+   * procedure of that name throws. Default false.
+   */
+  toolResults?: boolean;
 }
 /**
  * What `withModel` takes: everything that exists only because a model does.
@@ -590,6 +610,13 @@ export interface ChatTurn {
 export interface ResolvedPage {
   /** The design checks' advice, numbered like `diagnostics`. */
   advice: ReadonlyArray<Advice>;
+  /**
+   * Provided data the page is drawn with, by slot: what `resolvePage`
+   * returned beside the source. Empty for a shipped page, whose route
+   * supplies its slots. Pass it to the view with the app's own slots:
+   * `data={{ ...page.data, ...own }}`.
+   */
+  data: Readonly<Record<string, JsonValue>>;
   /**
    * Never an error or warning for a shipped page, or a saved one compiled
    * with `strict`. A saved page is lenient by default: these say what
@@ -644,6 +671,11 @@ export interface JigsServer<TContext, TPageName extends string = never> {
     advice: ReadonlyArray<Advice>;
     diagnostics: ReadonlyArray<Diagnostic>;
     program: Program;
+    /**
+     * With `toolResults: true`, for a source that reads the slot: the tool
+     * names it reads, or `"all"` (`ChatBlock.toolKeys`).
+     */
+    toolKeys?: ReadonlyArray<string> | "all";
   }>;
   /**
    * `value` parsed with the schema of provided slot `name`, for a page

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jigs.design/server",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "createJigsServer: checks and streams programs, runs procedures, and serves the sandbox frame.",
   "license": "MIT",
   "repository": {
@@ -29,11 +29,11 @@
     "access": "public"
   },
   "dependencies": {
-    "@jigs.design/host": "0.3.1",
-    "@jigs.design/compiler": "0.3.1",
-    "@jigs.design/protocol": "0.3.1",
-    "@jigs.design/runtime": "0.3.1",
-    "@jigs.design/prompt": "0.3.1"
+    "@jigs.design/prompt": "0.3.3",
+    "@jigs.design/host": "0.3.3",
+    "@jigs.design/compiler": "0.3.3",
+    "@jigs.design/protocol": "0.3.3",
+    "@jigs.design/runtime": "0.3.3"
   },
   "peerDependencies": {
     "zod": "^4.0.0"