@lotics/app-sdk 0.102.3 → 0.104.0

package/AGENTS.md

@@ -17,7 +17,7 @@ This file is the index. The **exact type** of anything is its shipped declaratio
 |---|---|
 | [docs/data_fetching.md](./docs/data_fetching.md) | The reads: `useQuery(alias, params, opts)` — its rows (`limit`), numbered pages (`page`), a keyset feed (`more`), its `total` or the total alone, with `total: { by }` a count per value of one column — `useQueries` for reads known only at render, `queryAll` outside React, `exportQuery` for a file of them the server makes; every hook answers one `QueryState`. The ROW type (`RowOf` — the alias's projected columns and nothing else), runtime `sort`/`filter` keys, cell readers (`row.*`, `readSelect`, `readMembers`, `readLinks`, `readFiles`, `readLocked`, `readCreatedAt`/`readUpdatedAt`), the SDK's own cache — **arrival revalidates** — **realtime push**, a write drawn on every read from the press, a count as its own full scan, and the search-as-you-type and record-picker patterns. |
 | [docs/queries.md](./docs/queries.md) | **The query engine reference** — AST node kinds, per-field-type operators, filters/params/pruning, free-text search, combining tables, shaping (aggregates, date buckets, windows), runtime refinement bounds, limits and the efficiency playbook. |
-| [docs/mutations.md](./docs/mutations.md) | `useWorkflow` (the ONLY write path; `useWorkflows` for writes that are data), the `WorkflowResult` resolve-never-throw contract (`field_errors`), typed inputs, every write drawn on every read from the press — predicted from the workflow's own steps, taken back on a refusal, `pending` meanwhile — the re-read a successful write triggers over the tables its body names, diff-before-update, locked records, `useNewRecord`, read-after-write ordering (`writesSettled()`), `useRecording`. |
+| [docs/mutations.md](./docs/mutations.md) | `useWorkflow` (the ONLY write path; `useWorkflows` for writes that are data), the `WorkflowResult` resolve-never-throw contract (`field_errors`), typed inputs, every write drawn on every read from the press — predicted from the workflow's own steps, taken back on a refusal, `pending` meanwhile — the re-read a successful write triggers over the tables its body names, diff-before-update, locked records, `useNewRecord`, read-after-write ordering (`writesSettled()`), `useRecording`, `useRecordings` over several aliases. |
 | [docs/workflows.md](./docs/workflows.md) | **The workflow-BODY reference** — the JS subset a body may use, opaque `fld_*`/`opt_*` keys, every step form, the accepted sugar, helpers, record-write surfaces, the traps and the verify loop. |
 | [docs/recipes.md](./docs/recipes.md) | Task-shaped how-tos — returning a generated file, returning structured data, parameterized lookups, composable optional filters, cell decoding, testing an AI action without spending credits. |
 | [docs/files.md](./docs/files.md) | Files end to end — `useFileUpload` and its `fidelity`, `renameFile` (a new file over the same bytes), `useAttachments`/`useAttachmentPiles`, `readFiles` and presigned URLs (a bearer credential — never logged or persisted), workflow-generated files, naming a zip's entries, the delivery bounds. |

package/dist/{chunk-ZOFKWF6V.js → chunk-CRJQYSDI.js}

@@ -444,9 +444,14 @@ async function runUploadPipeline(file, rpc2, options = {}) {
 var IDLE_RECORDING = { phase: "idle" };
 var states = /* @__PURE__ */ new Map();
 var listeners = /* @__PURE__ */ new Set();
+var version = 0;
 function emit() {
+  version += 1;
   for (const listener of listeners) listener();
 }
+function recordingsVersion() {
+  return version;
+}
 function subscribeRecordings(listener) {
   listeners.add(listener);
   return () => {
@@ -1115,6 +1120,7 @@ async function standaloneUpload(file, fidelity) {
 export {
   __export,
   DEFAULT_IMAGE_FIDELITY,
+  recordingsVersion,
   subscribeRecordings,
   recordingStateOf,
   anyRecordingLive,

package/dist/index.d.ts

@@ -11,8 +11,8 @@ export type { AttachedFile, AttachmentPiles, AttachmentPilesOptions, Attachments
 export { useComments, useCommentCounts } from "./comments.js";
 export type { AppComment, AppCommentAuthor, AppCommentFile, CommentsState, UseCommentsArgs, CommentCountsState, UseCommentCountsArgs, } from "./comments.js";
 export { useAppContext, useViewer, useWorkspaceCurrency, useWorkspaceTimezone } from "./viewer.js";
-export { useRecording } from "./recording.js";
-export type { UseRecording } from "./recording.js";
+export { useRecording, useRecordings } from "./recording.js";
+export type { UseRecording, UseRecordings } from "./recording.js";
 export type { RecordingState, RecordingInputs } from "./recording_state.js";
 export { requestGeofencedLocation, isWithinZone } from "./geolocation.js";
 export type { GeofenceZone, GeoCoords, GeofenceOutcome, GeofenceOptions } from "./geolocation.js";

package/dist/index.js

@@ -12,6 +12,7 @@ import {
   postHostNotification,
   readRecordingSnapshot,
   recordingStateOf,
+  recordingsVersion,
   replaceRecordings,
   rpc,
   rpcAgentRun,
@@ -21,7 +22,7 @@ import {
   subscribeRecordings,
   subscribeUrlParams,
   urlParam
-} from "./chunk-ZOFKWF6V.js";
+} from "./chunk-CRJQYSDI.js";
 
 // src/mount.tsx
 import { createRoot } from "react-dom/client";
@@ -24213,7 +24214,7 @@ var appWorkflowContractSchema = zod_default.object({
   inputs: zod_default.record(zod_default.string(), appWorkflowInputSchema).optional(),
   outputs: zod_default.record(zod_default.string(), appWorkflowOutputSchema).optional()
 });
-var APP_EXPORT_REPORT_KEYS = ["title", "lines", "readings"];
+var APP_EXPORT_REPORT_KEYS = ["title", "lines", "readings", "at", "dates"];
 var appExportTemplateSchema = zod_default.object({
   template_id: zod_default.string().min(1).describe("The document template (`dtl_\u2026`) filled: an Excel workbook, or an HTML page made a PDF."),
   rows: zod_default.string().regex(APP_ALIAS_REGEX).refine((key) => !APP_EXPORT_REPORT_KEYS.some((taken) => taken === key), {
@@ -24234,6 +24235,11 @@ var appQueryDeclarationSchema = zod_default.object({
     "Document templates an export of this query's rows may fill, by the name the export asks for. An export names one of these or none; a template it does not declare is refused."
   )
 });
+var appAgentWritesSchema = zod_default.object({
+  table_id: zod_default.string().min(1).describe("The table of the row written"),
+  row: zod_default.string().min(1).describe("The input naming that row: a single `record_link` input to `table_id`"),
+  fields: zod_default.record(zod_default.string().min(1), zod_default.string().min(1)).refine((fields) => Object.keys(fields).length > 0, { message: "writes.fields maps at least one output" }).describe("Output name \u2192 the field key of `table_id` it is written to")
+}).strict();
 var appAgentDeclarationSchema = zod_default.object({
   instructions: zod_default.string().min(1).describe("System instructions for the agent \u2014 the task it performs per run."),
   tool_names: zod_default.array(zod_default.string().min(1)).describe(
@@ -24265,6 +24271,9 @@ var appAgentDeclarationSchema = zod_default.object({
   ).refine(
     (outputs) => outputs === void 0 || Object.values(outputs).every((o) => appWorkflowOutputDepth(o) <= MAX_APP_WORKFLOW_OUTPUT_DEPTH),
     { message: `output schema nesting exceeds the max depth of ${MAX_APP_WORKFLOW_OUTPUT_DEPTH}` }
+  ),
+  writes: appAgentWritesSchema.optional().describe(
+    "Where the run's outputs land: each named output written to a field of the one row an input names, under the app's authority, once the result validates \u2014 locks and hooks apply as to any update. Omit for an agent whose output is only returned."
   )
 });
 var appThemeSchema = zod_default.object({
@@ -24396,6 +24405,12 @@ var agentStepSchema = stepBaseSchema.extend({
   model_tier: zod_default.enum(MODEL_TIERS).optional(),
   output: agentOutputSpecSchema
 });
+var appAgentStepSchema = stepBaseSchema.extend({
+  type: zod_default.literal("app_agent"),
+  alias: zod_default.string().min(1),
+  input: zod_default.record(zod_default.string(), toolInputValueSchema),
+  wait: zod_default.literal(false).optional()
+});
 var breakStepSchema = stepBaseSchema.extend({
   type: zod_default.literal("break")
 });
@@ -24422,6 +24437,7 @@ var workflowStepSchema = zod_default.lazy(
     returnStepSchema,
     validateStepSchema,
     agentStepSchema,
+    appAgentStepSchema,
     breakStepSchema,
     continueStepSchema,
     letDeclareStepSchema,
@@ -25044,6 +25060,7 @@ function stepChildStepArrays(step) {
     case "bind":
     case "validate":
     case "agent":
+    case "app_agent":
     case "break":
     case "continue":
     case "let_declare":
@@ -25076,6 +25093,7 @@ function changesRows(toolName) {
 }
 function rowWriteOf(step) {
   if (step.type === "agent") return step.tool_names.some(changesRows) ? { table_id: null } : void 0;
+  if (step.type === "app_agent") return { table_id: null };
   if (step.type !== "tool_call") return void 0;
   const rows = toolRows(step.tool_name);
   if (rows === null) return void 0;
@@ -27204,7 +27222,8 @@ async function run(walk, step) {
       if (write2 !== void 0) note(walk, { kind: "unknown", table_id: write2.table_id });
       return unknownAt(walk.ctx.step_outputs, step.id);
     }
-    case "agent": {
+    case "agent":
+    case "app_agent": {
       const write2 = rowWriteOf(step);
       if (write2 !== void 0) note(walk, { kind: "unknown", table_id: write2.table_id });
       return unknownAt(walk.ctx.step_outputs, step.id);
@@ -31086,33 +31105,54 @@ function useCommentCounts(args) {
 }
 
 // src/recording.ts
-import { useCallback as useCallback7, useSyncExternalStore as useSyncExternalStore3 } from "react";
+import { useCallback as useCallback7, useMemo as useMemo4, useSyncExternalStore as useSyncExternalStore3 } from "react";
 var NO_MOCKS = {};
+async function startRecording(alias, inputs) {
+  if (getMockRecordings()?.[alias]) return { started: true };
+  return rpc("recording.start", { alias, inputs });
+}
+async function stopRecording(alias) {
+  if (getMockRecordings()?.[alias]) return;
+  await rpc("recording.stop", { alias });
+}
+function busyWith(mocks, hostBusy) {
+  return hostBusy || Object.values(mocks).some((state) => state.phase === "live");
+}
 function useRecording(alias) {
   const { recordingEnabled } = useAppContext();
   const mocks = getMockRecordings() ?? NO_MOCKS;
   const mocked = mocks[alias];
   const hostState = useSyncExternalStore3(subscribeRecordings, () => recordingStateOf(alias));
   const hostBusy = useSyncExternalStore3(subscribeRecordings, anyRecordingLive);
-  const start = useCallback7(
-    async (inputs) => {
-      if (getMockRecordings()?.[alias]) return { started: true };
-      return rpc("recording.start", { alias, inputs: inputs ?? {} });
-    },
-    [alias]
-  );
-  const stop = useCallback7(async () => {
-    if (getMockRecordings()?.[alias]) return;
-    await rpc("recording.stop", { alias });
-  }, [alias]);
+  const start = useCallback7((inputs) => startRecording(alias, inputs ?? {}), [alias]);
+  const stop = useCallback7(() => stopRecording(alias), [alias]);
   return {
     available: mocked !== void 0 || recordingEnabled,
     state: mocked ?? hostState,
-    busy: hostBusy || Object.values(mocks).some((state) => state.phase === "live"),
+    busy: busyWith(mocks, hostBusy),
     start,
     stop
   };
 }
+function useRecordings(aliases) {
+  const { recordingEnabled } = useAppContext();
+  const mocks = getMockRecordings() ?? NO_MOCKS;
+  const version3 = useSyncExternalStore3(subscribeRecordings, recordingsVersion);
+  const hostBusy = useSyncExternalStore3(subscribeRecordings, anyRecordingLive);
+  const key = aliases.join("\n");
+  const states = useMemo4(
+    () => Object.fromEntries(key.split("\n").filter((alias) => alias !== "").map((alias) => [alias, mocks[alias] ?? recordingStateOf(alias)])),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [key, version3, mocks]
+  );
+  return {
+    available: recordingEnabled || aliases.some((alias) => mocks[alias] !== void 0),
+    states,
+    busy: busyWith(mocks, hostBusy),
+    start: startRecording,
+    stop: stopRecording
+  };
+}
 
 // src/geolocation.ts
 var EARTH_RADIUS_M = 6371e3;
@@ -31320,7 +31360,7 @@ function useRecents(key, options = {}) {
 }
 
 // src/use_url_state.ts
-import { useCallback as useCallback9, useEffect as useEffect6, useMemo as useMemo4, useRef as useRef5, useState as useState5 } from "react";
+import { useCallback as useCallback9, useEffect as useEffect6, useMemo as useMemo5, useRef as useRef5, useState as useState5 } from "react";
 function useUrlState(defs) {
   const defsRef = useRef5(defs);
   defsRef.current = defs;
@@ -31340,7 +31380,7 @@ function useUrlState(defs) {
       unsubscribe();
     };
   }, []);
-  const values2 = useMemo4(() => decodeAll(defsRef.current, params), [params]);
+  const values2 = useMemo5(() => decodeAll(defsRef.current, params), [params]);
   const setValues = useCallback9(
     (patch) => {
       editedRef.current = true;
@@ -31424,6 +31464,7 @@ export {
   useQuery,
   useRecents,
   useRecording,
+  useRecordings,
   useUrlState,
   useViewer,
   useWorkflow,

package/dist/queries.d.ts

@@ -185,6 +185,13 @@ export interface ExportReport {
     title: string;
     lines: string[];
     readings: ReportReading[];
+    /** Each date filter narrowing the rows, by field alias: its bounds, a day or a minute of one, with no zone. */
+    dates?: Record<string, {
+        from?: string;
+        to?: string;
+    }>;
+    /** The file's name, in the template grammar over the report; absent, the template's name, or `title`. */
+    filename?: string;
 }
 /** The file an export makes: the default report workbook — its words in `language`, the rows under `columns` on the
  *  tab `sheet` — or a template the query declares under `templates`, by its name there. */

package/dist/recording.d.ts

@@ -44,4 +44,22 @@ export interface UseRecording<I> {
  */
 export declare function useRecording<K extends keyof AppWorkflows & string>(alias: K): UseRecording<ActInputsOf<K>>;
 export declare function useRecording(alias: string): UseRecording<Record<string, unknown>>;
+export interface UseRecordings {
+    /** As {@link UseRecording}'s: whether the host records here at all. */
+    available: boolean;
+    /** The latest recording through each alias asked, idle where none ran. */
+    states: Readonly<Record<string, RecordingState>>;
+    /** Any of this app's recordings is live, through any alias. */
+    busy: boolean;
+    start: (alias: string, inputs: Record<string, unknown>) => Promise<{
+        started: boolean;
+    }>;
+    stop: (alias: string) => Promise<void>;
+}
+/**
+ * {@link useRecording} over several aliases at once — for a screen drawing an
+ * unknown number of recording acts, which cannot call a hook per alias. One
+ * snapshot per change: the host's every-second push while live redraws once.
+ */
+export declare function useRecordings(aliases: readonly string[]): UseRecordings;
 export {};

package/dist/recording_state.d.ts

@@ -33,6 +33,7 @@ export type RecordingState = {
     inputs: RecordingInputs;
 };
 export declare const IDLE_RECORDING: RecordingState;
+export declare function recordingsVersion(): number;
 export declare function subscribeRecordings(listener: () => void): () => void;
 export declare function recordingStateOf(alias: string): RecordingState;
 export declare function anyRecordingLive(): boolean;

package/dist/router.js

@@ -1,7 +1,7 @@
 import {
   isEmbedded,
   setUrlParams
-} from "./chunk-ZOFKWF6V.js";
+} from "./chunk-CRJQYSDI.js";
 
 // src/router.tsx
 import { useEffect } from "react";

package/docs/ai.md

@@ -29,6 +29,7 @@ A declaration carries:
 | `prefix_cache_ttl` | Optional prompt-cache window for the agent's stable prefix (tools + system). **Omit it** — the default `"5m"` is right for essentially every agent. `"1h"` writes at 2x the input rate (against 1.25x) to buy only the five-minute-to-one-hour band; set it only with measured cadence showing runs land there, such as a scheduled sweep |
 | `inputs` | Optional typed input schema for one run — the same vocabulary as workflow inputs (`text`, `number`, `file`, `member`, `record_link`, `select`, …). The server validates every run payload against it. **Every field defaults to `required: true`**, exactly as `outputs` does — the two extend the same base — so an input the caller may legitimately omit needs `"required": false`, or the run is rejected before the agent sees it |
 | `outputs` | Optional typed output schema — the declaration vocabulary, including the two ways a `select` names its option set, is [mutations](./mutations.md#structured-results-return-data). Declared → **structured agent** (the run must emit a matching result); omitted → **free-text agent** (the answer is the final prose). **Every field defaults to `required: true`** (the same base schema as `inputs` above) — mark `"required": false` on anything the source may legitimately not carry. It matters most for `number`, which has no blank: text can answer `""`, but a required number leaves only a wrong value or a rejected submission |
+| `writes` | Optional — where the result lands: `{ table_id, row, fields }`. `row` is a single `record_link` input to `table_id`; `fields` maps each output to a field key of that table. Once a run's result validates, each output it carries is written to that row under the app's authority, with the table's locks and hooks applied; an output the result omits is left alone. A write that fails fails the run. Requires `outputs` |
 
 **Structured vs free-text is the load-bearing split.** A structured agent's result arrives in `run.output` (the server strictly validates the submitted result against the declared schema — see the `output` typing section for the exact guarantee); a free-text agent's answer is the transcript's prose (`run.text`) and its `output` stays `undefined` — never a stray string, so a consumer reading `output.<field>` can't crash on a free-text answer.
 

package/docs/data_fetching.md

@@ -24,7 +24,7 @@ and by `lotics app create --custom` and `lotics app deploy`. Every hook reads th
 | `useQuery(alias, params?, { rows: false, total: true })` | `total` only, no rows (`total: { by: column }` adds `counts`) | a facet chip, a queue badge, an "N awaiting approval" tile — the size of a set you are not listing |
 | `useQueries(calls, opts?)` | one state per `{ alias, params?, filter?, sort?, aggregate?, total?, rows? }`, in order — a `sort` orders that call's rows before the cap cuts them | reads that are DATA — a list known only at render, one read per item, or one count per stage (`rows: false, total: true`, each state's `.total`); the deploy's alias scan reads a list as dynamic, so every alias in it is still declared. With `aggregate` a call answers the groups of its filtered rows instead of the rows ([queries](./queries.md)) |
 | `queryAll(alias, params?, { filter, sort })` | a promise of every row | outside React, for a job that must hold the whole narrowed set in the browser (the ids an act runs on): it asks page after page until the server says the set ended, never stopping at the 10,000-row cap. The server's rows as stored — no write of this app is drawn over them |
-| `exportQuery(alias, { params, filter, sort, report, file })` | a promise of the file | every row the narrowed set holds, made into one file by the server — no row reaches the browser. `report` is `{ title, lines, readings }`; `file` is `{ kind: "workbook", language, sheet, columns }` (the default report workbook, each column `{ key, header, type }` an output column of the query — a `number` one on a number column, a `date` one on a date or datetime) or `{ kind: "template", template }`, one the query declares under `templates` by name ([queries](./queries.md)). Past 20,000 rows it rejects, never cuts; each caller makes at most 60 exports a minute. The file's `url` is signed for the caller: open it with `openExternal` |
+| `exportQuery(alias, { params, filter, sort, report, file })` | a promise of the file | every row the narrowed set holds, made into one file by the server — no row reaches the browser. `report` is `{ title, lines, readings, dates?, filename? }` — `dates` each date filter's `{ from?, to? }` by field alias, each bound a day (`yyyy-MM-dd`) or a minute of one (`yyyy-MM-ddTHH:mm`) with no zone; `filename` the file's name in the template grammar over one value each — `title`, `at` (the moment the server made the file), `dates.<field>.from` or `.to`, `lines | lookup:<n>` — at most 200 bytes once filled (absent, the template's name, or `title`); `file` is `{ kind: "workbook", language, sheet, columns }` (the default report workbook, its head closing with the moment the server made it, each column `{ key, header, type }` an output column of the query — a `number` one on a number column, a `date` one on a date or datetime) or `{ kind: "template", template }`, one the query declares under `templates` by name ([queries](./queries.md)). Past 20,000 rows it rejects, never cuts; each caller makes at most 60 exports a minute. The file's `url` is signed for the caller: open it with `openExternal` |
 
 Every hook answers the same `QueryState`: `rows`, `truncated`, `total`, `counts`, `loading`,
 `isValidating`, `error`, `pending`, `refetch`, `page`, `setPage`, `pageCount`, `hasMore`,

package/docs/mutations.md

@@ -674,6 +674,11 @@ replaces the first's state):
 | `filed` | `execution_id`, `inputs` | the workflow ran and succeeded |
 | `failed` | `message`, `inputs` | transcription failed, or filing was refused or its run failed |
 
+A screen drawing a number of recording acts it only learns at run time reads them together with
+**`useRecordings(aliases)`**: `available` and `busy` as above, `states` (each alias's latest
+recording, idle where none ran), and `start(alias, inputs)` / `stop(alias)` — the same calls, by
+alias.
+
 `inputs` is what `start` was passed, so a screen with one act per row can tell which row the
 recording is about. **`busy`** is true while any recording this app started is live, through
 any alias: stand the other acts down, since the host would refuse them. A recording in another

package/docs/workflows.md

@@ -150,6 +150,7 @@ The body is a sequence of statements, each of which maps 1:1 onto a stored step.
 | Pause for an event | `await wait_for_event({ event_type: "payment" \| "webhook", event_ref, timeout_in_minutes? });` |
 | Pause for a decision | `const a = await wait_for_approval({ approvers, prompt, timeout_in_minutes? });` |
 | LLM reasoning | `const x = await agent({ instructions, input, tools, model?, output });` |
+| Run a declared agent | `const x = await app_agent({ alias, input, wait? });` |
 | Guard | `validate({ checks: [{ fail_when, field_key?, message }, …] });` |
 | End the run | `return({ status, message, field_errors?, data? });` |
 
@@ -313,6 +314,22 @@ name" when broken:
 `model` is an optional pin — omit it to follow the platform default. The step is atomic (no wait
 or approval inside it).
 
+### `app_agent` — run one of this app's agents as one step
+
+```js
+const scored = await app_agent({ alias: "scorer", input: { deal: trigger.app_workflow.inputs.deal } });
+```
+
+`alias` names an agent this app declares; `input` is an object literal checked against its
+`inputs`. The step resolves to the agent's declared `outputs` — typed, so `scored.summary` is
+checked at save — or to its final text when it declares none, and applies the agent's `writes`.
+The run shows in the agent's history like any other. It exists only in an app's own workflows,
+and a run an agent started (through `run_app_workflow`) refuses it: an agent never starts an agent.
+
+`wait: false` starts the run and resolves at once to `{ run_id }`. The workflow goes on, and what
+it wrote stands; the agent's result — its `writes` included — lands when the run settles, and a
+run that fails fails in the agent's history, not the workflow.
+
 ### `try` / `catch`
 
 ```js

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lotics/app-sdk",
-  "version": "0.102.3",
+  "version": "0.104.0",
   "description": "The SDK a Lotics custom-code app reads and writes through \u2014 typed hooks over the host bridge, cell readers, mount() and AppRouter",
   "type": "module",
   "exports": {