@aparte/provider-scenario 0.14.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 aparté
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,48 @@
+# @aparte/provider-scenario
+
+A **scripted model** for aparté: it replays turns you wrote — text at a typing pace,
+thinking, tool calls, errors, pauses — instead of calling a model. No key, no network,
+the same answer every time. For demos and docs that should stream something real, and
+for **your own tests**, which get a deterministic model.
+
+```bash
+npm install @aparte/provider-scenario @aparte/core
+```
+
+`@aparte/core` is the only **peer dependency**; this package has none of its own.
+
+```ts
+import { aparteGlobalConfig, AparteClient, AparteDirectTransport } from '@aparte/core';
+import { createScenarioProvider } from '@aparte/provider-scenario';
+
+aparteGlobalConfig.registerAIProvider(createScenarioProvider({
+  turns: [
+    'Hello! Ask me anything.',
+    [{ thinking: 'Let me see…' }, { text: 'Here is my **answer**.' }],
+  ],
+}));
+aparteGlobalConfig.setTransport(new AparteDirectTransport({ byok: true }));
+new AparteClient().start();
+```
+
+`turns` answers calls in order and repeats the last one. For a model that answers
+*according to what was asked*, name scenarios and let `when` / `after` pick:
+
+```ts
+createScenarioProvider({
+  scenarios: {
+    default: 'Ask me for a haiku, or the weather.',
+    haiku:   { when: /haiku/i, turn: 'Web components hum —  \nno framework in the wind,  \njust the page, alive.' },
+    weather: { when: 'weather', turn: [{ text: 'Let me check.' }, { tool: 'get_weather', input: { city: 'Lille' } }] },
+    forecast: { after: 'get_weather', turn: 'Cloudy, 14 °C. Bring a jacket.' },
+  },
+});
+```
+
+A tool step calls the tool you registered on the config; the real loop runs its handler
+and calls the provider again with the result, which `after` answers. `pacing:
+{ chunk, delay }` sets the typing speed; `pacing: 'instant'` gives a test the whole
+reply at once. `showcase` is a ready-made set covering markdown, code, reasoning, a tool
+round-trip, a typed question (`ask_user`), an artifact and an error.
+
+Full guide: [apartejs.dev/providers/ai/scenario](https://apartejs.dev/providers/ai/scenario/).

package/dist/index.d.ts

@@ -0,0 +1,127 @@
+/**
+ * @aparte/provider-scenario — a scripted model.
+ *
+ * An `AparteAIProvider` that REPLAYS turns you wrote instead of calling a model: text at
+ * a typing pace, thinking, tool calls (the real loop runs your handler and calls back
+ * with the result), errors, pauses. No key, no network, no randomness.
+ *
+ * Three things in this repository had written it by hand before this package existed:
+ * the e2e mock of the wire, the screenshot harness of the UI audit, and the docs frames
+ * that seed content. It is also the piece nobody ships for CONSUMERS: a deterministic
+ * model for their own tests, and a demo that streams without a backend.
+ *
+ * It owns its I/O — `chat()` — so `AparteDirectTransport` hands the request straight to
+ * it; there is no wire format here to adapt. (This repository's own e2e keeps its
+ * network mock on purpose: that suite tests the real wire path, which this provider
+ * bypasses by construction.)
+ *
+ * ```ts
+ * import { createScenarioProvider } from '@aparte/provider-scenario';
+ * aparteGlobalConfig.registerAIProvider(createScenarioProvider({
+ *   turns: ['Hello! Ask me anything.', [{ thinking: 'Let me see…' }, { text: 'Here is my answer.' }]],
+ * }));
+ * ```
+ */
+import type { AparteAIModel, AparteAIProvider, AparteChatRequest, AparteStreamEvent, AparteUsage } from '@aparte/core';
+/** One thing the scripted model does, in order. */
+export type ScenarioStep = 
+/** Stream this text, chunk by chunk at the configured pace. Markdown and `<artifact>` tags are fine: core parses them. */
+{
+    text: string;
+}
+/** Stream this as reasoning (the thinking block). */
+ | {
+    thinking: string;
+}
+/** Call a tool. The loop runs the registered handler, then calls the provider again with the result. */
+ | {
+    tool: string;
+    input?: Record<string, unknown>;
+    id?: string;
+}
+/** Fail the turn with this message — what a provider error looks like to the UI. */
+ | {
+    error: string;
+}
+/** Pause, in milliseconds — a slow model, a long tool. */
+ | {
+    wait: number;
+}
+/** Override the usage reported at the end (merged over the estimate). */
+ | {
+    usage: Partial<AparteUsage>;
+};
+/** What the model does for ONE call. A bare string is one text step. */
+export type ScenarioTurn = string | ScenarioStep[];
+/** A turn with the conditions under which it answers. */
+export interface Scenario {
+    /**
+     * Answers when the last user message matches: a string is a case-insensitive
+     * substring, a RegExp is tested as is.
+     */
+    when?: string | RegExp;
+    /** Answers the call that follows this tool's result — the second half of a tool round-trip. */
+    after?: string;
+    turn: ScenarioTurn;
+}
+/** How fast text streams. */
+export interface ScenarioPacing {
+    /** Characters per chunk. Default 12. */
+    chunk?: number;
+    /** Milliseconds between chunks. Default 24. */
+    delay?: number;
+}
+export interface ScenarioProviderOptions {
+    /** Provider id, as seen by core (key resolution, model picker, events). Default `scenario`. */
+    id?: string;
+    /** Display name. Default `Scripted model`. */
+    name?: string;
+    /**
+     * Calls answered in order; the last one repeats. The simplest form — a demo that
+     * always goes the same way, a test that needs three replies. Every call to the
+     * model advances, a tool round-trip included.
+     */
+    turns?: ScenarioTurn[];
+    /**
+     * Named scenarios, one of which answers each call — picked by `match`, or by the
+     * default: the `after` of a tool result, else the first `when` that matches the
+     * last user message, else `default`, else the first one. A bare turn value is
+     * `{ turn }`.
+     */
+    scenarios?: Record<string, Scenario | ScenarioTurn>;
+    /** Picks the scenario for a call, by name. Return `undefined` to fall back to the default rule. */
+    match?: (request: AparteChatRequest, scenarios: Record<string, Scenario>) => string | undefined;
+    /** Typing pace, or `'instant'` for a test that wants the whole reply at once. */
+    pacing?: ScenarioPacing | 'instant';
+    /** The models the picker offers. Default: one, `scripted`, declaring streaming and tools. */
+    models?: AparteAIModel[];
+}
+/**
+ * The default rule: a tool result goes to the scenario that declared `after` for that
+ * tool; otherwise the first scenario whose `when` matches the last user message;
+ * otherwise `default`; otherwise the first scenario declared.
+ */
+export declare function defaultMatch(request: AparteChatRequest, scenarios: Record<string, Scenario>): string | undefined;
+/**
+ * Play one turn as the event stream the loop reads.
+ *
+ * Exported for a test or a tool that wants the events without a provider around them.
+ */
+export declare function playTurn(turn: ScenarioTurn, request: AparteChatRequest, pacing?: ScenarioPacing | 'instant', signal?: AbortSignal): ReadableStream<AparteStreamEvent>;
+/**
+ * Build the scripted provider. Register it like any other:
+ *
+ * ```ts
+ * aparteGlobalConfig.registerAIProvider(createScenarioProvider({
+ *   scenarios: {
+ *     default: 'Ask me for a haiku, a table, or the weather.',
+ *     haiku: { when: /haiku/i, turn: 'Web components hum —  \nno framework in the wind,  \njust the page, alive.' },
+ *     weather: { when: 'weather', turn: [{ text: 'Let me check.' }, { tool: 'get_weather', input: { city: 'Lille' } }] },
+ *     forecast: { after: 'get_weather', turn: 'Cloudy, 14 °C. Bring a jacket.' },
+ *   },
+ * }));
+ * ```
+ */
+export declare function createScenarioProvider(options?: ScenarioProviderOptions): AparteAIProvider;
+export { showcase } from './presets.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EACR,aAAa,EACb,gBAAgB,EAEhB,iBAAiB,EAEjB,iBAAiB,EACjB,WAAW,EACd,MAAM,cAAc,CAAC;AAItB,mDAAmD;AACnD,MAAM,MAAM,YAAY;AACpB,0HAA0H;AACxH;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE;AAClB,qDAAqD;GACnD;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE;AACtB,wGAAwG;GACtG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAAC,EAAE,CAAC,EAAE,MAAM,CAAA;CAAE;AAChE,oFAAoF;GAClF;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE;AACnB,0DAA0D;GACxD;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE;AAClB,yEAAyE;GACvE;IAAE,KAAK,EAAE,OAAO,CAAC,WAAW,CAAC,CAAA;CAAE,CAAC;AAEtC,wEAAwE;AACxE,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,YAAY,EAAE,CAAC;AAEnD,yDAAyD;AACzD,MAAM,WAAW,QAAQ;IACrB;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACvB,+FAA+F;IAC/F,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,YAAY,CAAC;CACtB;AAED,6BAA6B;AAC7B,MAAM,WAAW,cAAc;IAC3B,wCAAwC;IACxC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,+CAA+C;IAC/C,KAAK,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,uBAAuB;IACpC,+FAA+F;IAC/F,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,8CAA8C;IAC9C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;OAIG;IACH,KAAK,CAAC,EAAE,YAAY,EAAE,CAAC;IACvB;;;;;OAKG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,GAAG,YAAY,CAAC,CAAC;IACpD,mGAAmG;IACnG,KAAK,CAAC,EAAE,CAAC,OAAO,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,KAAK,MAAM,GAAG,SAAS,CAAC;IAChG,iFAAiF;IACjF,MAAM,CAAC,EAAE,cAAc,GAAG,SAAS,CAAC;IACpC,6FAA6F;IAC7F,MAAM,CAAC,EAAE,aAAa,EAAE,CAAC;CAC5B;AA8BD;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,GAAG,MAAM,GAAG,SAAS,CAehH;AAkBD;;;;GAIG;AACH,wBAAgB,QAAQ,CACpB,IAAI,EAAE,YAAY,EAClB,OAAO,EAAE,iBAAiB,EAC1B,MAAM,GAAE,cAAc,GAAG,SAAc,EACvC,MAAM,CAAC,EAAE,WAAW,GACrB,cAAc,CAAC,iBAAiB,CAAC,CAoDnC;AAID;;;;;;;;;;;;;GAaG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,GAAE,uBAA4B,GAAG,gBAAgB,CAuC9F;AAED,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -0,0 +1,214 @@
+const showcase = {
+  default: {
+    turn: "Hi — I am a **scripted** model: no key, no network, the same answer every time.\n\nAsk me for a *haiku*, a *table*, some *code*, the *weather*, or to *ask you a question*."
+  },
+  haiku: {
+    when: /haiku/i,
+    turn: "Web components hum —  \nno framework in the wind,  \njust the page, alive."
+  },
+  table: {
+    when: /table/i,
+    turn: "Two ways to reach a model:\n\n| Transport | Where the key lives | Use it for |\n|---|---|---|\n| `AparteDirectTransport` | in the browser | prototypes, local models |\n| `AparteBackendTransport` | on your server | production |\n\nThe component does not change between the two."
+  },
+  code: {
+    when: /code|example|snippet/i,
+    turn: [
+      { thinking: "The shortest useful wiring is three lines: register a provider, set a transport, start the client." },
+      { text: "The minimal wiring:\n\n```ts\nimport { AparteClient, aparteGlobalConfig, AparteDirectTransport } from '@aparte/core';\nimport { createScenarioProvider } from '@aparte/provider-scenario';\n\naparteGlobalConfig.registerAIProvider(createScenarioProvider({ turns: ['Hello!'] }));\naparteGlobalConfig.setTransport(new AparteDirectTransport({ byok: true }));\nnew AparteClient().start();\n```\n\nThree lines that matter." }
+    ]
+  },
+  weather: {
+    when: /weather|forecast/i,
+    turn: [
+      { text: "Let me check that for you." },
+      { tool: "get_weather", input: { city: "Lille" } }
+    ]
+  },
+  forecast: {
+    after: "get_weather",
+    turn: "Cloudy, 14 °C, a little wind from the west — bring a jacket."
+  },
+  question: {
+    when: /question|ask me|colou?r scheme/i,
+    turn: [
+      { text: "One thing first." },
+      {
+        tool: "ask_user",
+        input: {
+          questions: [{
+            question: "Which mood for your landing page?",
+            header: "Mood",
+            options: [
+              { title: "Dark and quiet", description: "ink, brass accents", recommended: true },
+              { title: "Light and warm", description: "cream, soft contrast" },
+              { title: "Maximum contrast", description: "strict black and white" }
+            ]
+          }]
+        }
+      }
+    ]
+  },
+  answered: {
+    after: "ask_user",
+    turn: "Noted — I will go with that."
+  },
+  artifact: {
+    when: /artifact|document|write me/i,
+    turn: 'Here is a first draft:\n\n<artifact type="text/markdown" title="Launch note">## aparté\n\nA chat in Web Components, with the agent loop inside.\n\n- any framework\n- zero third-party dependencies\n</artifact>\n\nTell me what to change.'
+  },
+  slow: {
+    when: /slow|think hard|take your time/i,
+    turn: [
+      { thinking: "This deserves a moment." },
+      { wait: 2500 },
+      { text: "Done thinking. The answer is: it depends on the transport." }
+    ]
+  },
+  failure: {
+    when: /fail|error|crash/i,
+    turn: [{ error: "The scripted model exploded, as requested." }]
+  }
+};
+const textOf = (message) => {
+  if (!message) return "";
+  const { content } = message;
+  if (typeof content === "string") return content;
+  return content.map((part) => part.type === "text" ? part.text : "").join(" ");
+};
+const stepsOf = (turn) => typeof turn === "string" ? [{ text: turn }] : turn;
+const isTurn = (value) => typeof value === "string" || Array.isArray(value);
+const normalize = (scenarios) => {
+  const out = {};
+  for (const [key, value] of Object.entries(scenarios)) out[key] = isTurn(value) ? { turn: value } : value;
+  return out;
+};
+const toolNameOf = (messages, toolCallId) => {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const call = messages[i].toolCalls?.find((tc) => tc.id === toolCallId);
+    if (call) return call.name;
+  }
+  return void 0;
+};
+function defaultMatch(request, scenarios) {
+  const entries = Object.entries(scenarios);
+  const last = request.messages[request.messages.length - 1];
+  if (last?.role === "tool_result") {
+    const tool = toolNameOf(request.messages, last.toolCallId);
+    const hit = entries.find(([, s]) => s.after !== void 0 && s.after === tool);
+    if (hit) return hit[0];
+  }
+  const text = textOf(last);
+  for (const [key, s] of entries) {
+    if (s.when === void 0) continue;
+    if (typeof s.when === "string" ? text.toLowerCase().includes(s.when.toLowerCase()) : s.when.test(text)) return key;
+  }
+  if ("default" in scenarios) return "default";
+  return entries[0]?.[0];
+}
+const sleep = (ms, signal) => new Promise((resolve) => {
+  if (ms <= 0 || signal?.aborted) return resolve();
+  const timer = setTimeout(done, ms);
+  function done() {
+    clearTimeout(timer);
+    signal?.removeEventListener("abort", done);
+    resolve();
+  }
+  signal?.addEventListener("abort", done, { once: true });
+});
+const estimateTokens = (chars) => Math.ceil(chars / 4);
+let sequence = 0;
+function playTurn(turn, request, pacing = {}, signal) {
+  const chunk = pacing === "instant" ? Number.POSITIVE_INFINITY : Math.max(1, pacing.chunk ?? 12);
+  const delay = pacing === "instant" ? 0 : Math.max(0, pacing.delay ?? 24);
+  const steps = stepsOf(turn);
+  const inputChars = request.messages.reduce((n, m) => n + textOf(m).length, 0);
+  return new ReadableStream({
+    async start(controller) {
+      let outputChars = 0;
+      let usage = {};
+      const turnBegan = Date.now();
+      try {
+        for (const step of steps) {
+          if (signal?.aborted) break;
+          if ("wait" in step) {
+            await sleep(step.wait, signal);
+          } else if ("text" in step || "thinking" in step) {
+            const type = "text" in step ? "text" : "thinking";
+            const body = "text" in step ? step.text : step.thinking;
+            for (let i = 0; i < body.length; i += chunk) {
+              if (signal?.aborted) break;
+              const delta = body.slice(i, i + chunk);
+              controller.enqueue({ type, delta });
+              outputChars += delta.length;
+              if (delay > 0 && i + chunk < body.length) await sleep(delay, signal);
+            }
+          } else if ("tool" in step) {
+            controller.enqueue({ type: "tool_use", id: step.id ?? `scenario_${++sequence}`, name: step.tool, input: step.input ?? {} });
+          } else if ("error" in step) {
+            controller.enqueue({ type: "error", message: step.error });
+            controller.close();
+            return;
+          } else if ("usage" in step) {
+            usage = { ...usage, ...step.usage };
+          }
+        }
+        if (!signal?.aborted) {
+          const outputTokens = estimateTokens(outputChars);
+          const inputTokens = estimateTokens(inputChars);
+          controller.enqueue({
+            type: "done",
+            usage: { inputTokens, outputTokens, totalTokens: inputTokens + outputTokens, durationMs: Date.now() - turnBegan, ...usage }
+          });
+        }
+        controller.close();
+      } catch (err) {
+        controller.error(err);
+      }
+    }
+  });
+}
+function createScenarioProvider(options = {}) {
+  const id = options.id ?? "scenario";
+  const name = options.name ?? "Scripted model";
+  const models = options.models ?? [{
+    id: "scripted",
+    name,
+    description: "Replays scripted turns — no key, no network.",
+    capabilities: ["streaming", "function_calling"]
+  }];
+  const scenarios = normalize(options.scenarios ?? {});
+  const match = options.match ?? defaultMatch;
+  let calls = 0;
+  const pick = (request) => {
+    if (options.turns?.length) {
+      const turn = options.turns[Math.min(calls, options.turns.length - 1)];
+      calls++;
+      return turn;
+    }
+    const key = match(request, scenarios) ?? defaultMatch(request, scenarios);
+    const scenario = key !== void 0 ? scenarios[key] : void 0;
+    return scenario?.turn ?? "";
+  };
+  return {
+    id,
+    getMetadata: () => ({
+      id,
+      name,
+      description: "Replays scripted turns — no key, no network.",
+      isLocal: true,
+      configSchema: { fields: [] }
+    }),
+    getModels: () => models,
+    fetchModels: async () => models,
+    async chat(request, _config, ctx) {
+      return playTurn(pick(request), request, options.pacing, ctx?.signal);
+    }
+  };
+}
+export {
+  createScenarioProvider,
+  defaultMatch,
+  playTurn,
+  showcase
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../src/presets.ts","../src/index.ts"],"sourcesContent":["import type { Scenario } from './index.js';\n\n/**\n * A ready-made set of scenarios that shows the whole surface of a chat: markdown, a\n * code block, reasoning, a tool round-trip, a typed question, an artifact, an error.\n * The docs' live frames and a demo page can register it as is:\n *\n * ```ts\n * aparteGlobalConfig.registerAIProvider(createScenarioProvider({ scenarios: showcase }));\n * ```\n *\n * The tool names it calls — `get_weather`, `ask_user` — only do something if the app\n * registered a tool of that name; `@aparte/plugin-ask-user` provides the second.\n */\nexport const showcase: Record<string, Scenario> = {\n    default: {\n        turn: 'Hi — I am a **scripted** model: no key, no network, the same answer every time.\\n\\nAsk me for a *haiku*, a *table*, some *code*, the *weather*, or to *ask you a question*.',\n    },\n    haiku: {\n        when: /haiku/i,\n        turn: 'Web components hum —  \\nno framework in the wind,  \\njust the page, alive.',\n    },\n    table: {\n        when: /table/i,\n        turn: 'Two ways to reach a model:\\n\\n| Transport | Where the key lives | Use it for |\\n|---|---|---|\\n| `AparteDirectTransport` | in the browser | prototypes, local models |\\n| `AparteBackendTransport` | on your server | production |\\n\\nThe component does not change between the two.',\n    },\n    code: {\n        when: /code|example|snippet/i,\n        turn: [\n            { thinking: 'The shortest useful wiring is three lines: register a provider, set a transport, start the client.' },\n            { text: 'The minimal wiring:\\n\\n```ts\\nimport { AparteClient, aparteGlobalConfig, AparteDirectTransport } from \\'@aparte/core\\';\\nimport { createScenarioProvider } from \\'@aparte/provider-scenario\\';\\n\\naparteGlobalConfig.registerAIProvider(createScenarioProvider({ turns: [\\'Hello!\\'] }));\\naparteGlobalConfig.setTransport(new AparteDirectTransport({ byok: true }));\\nnew AparteClient().start();\\n```\\n\\nThree lines that matter.' },\n        ],\n    },\n    weather: {\n        when: /weather|forecast/i,\n        turn: [\n            { text: 'Let me check that for you.' },\n            { tool: 'get_weather', input: { city: 'Lille' } },\n        ],\n    },\n    forecast: {\n        after: 'get_weather',\n        turn: 'Cloudy, 14 °C, a little wind from the west — bring a jacket.',\n    },\n    question: {\n        when: /question|ask me|colou?r scheme/i,\n        turn: [\n            { text: 'One thing first.' },\n            {\n                tool: 'ask_user',\n                input: {\n                    questions: [{\n                        question: 'Which mood for your landing page?',\n                        header: 'Mood',\n                        options: [\n                            { title: 'Dark and quiet', description: 'ink, brass accents', recommended: true },\n                            { title: 'Light and warm', description: 'cream, soft contrast' },\n                            { title: 'Maximum contrast', description: 'strict black and white' },\n                        ],\n                    }],\n                },\n            },\n        ],\n    },\n    answered: {\n        after: 'ask_user',\n        turn: 'Noted — I will go with that.',\n    },\n    artifact: {\n        when: /artifact|document|write me/i,\n        turn: 'Here is a first draft:\\n\\n<artifact type=\"text/markdown\" title=\"Launch note\">## aparté\\n\\nA chat in Web Components, with the agent loop inside.\\n\\n- any framework\\n- zero third-party dependencies\\n</artifact>\\n\\nTell me what to change.',\n    },\n    slow: {\n        when: /slow|think hard|take your time/i,\n        turn: [\n            { thinking: 'This deserves a moment.' },\n            { wait: 2500 },\n            { text: 'Done thinking. The answer is: it depends on the transport.' },\n        ],\n    },\n    failure: {\n        when: /fail|error|crash/i,\n        turn: [{ error: 'The scripted model exploded, as requested.' }],\n    },\n};\n","/**\n * @aparte/provider-scenario — a scripted model.\n *\n * An `AparteAIProvider` that REPLAYS turns you wrote instead of calling a model: text at\n * a typing pace, thinking, tool calls (the real loop runs your handler and calls back\n * with the result), errors, pauses. No key, no network, no randomness.\n *\n * Three things in this repository had written it by hand before this package existed:\n * the e2e mock of the wire, the screenshot harness of the UI audit, and the docs frames\n * that seed content. It is also the piece nobody ships for CONSUMERS: a deterministic\n * model for their own tests, and a demo that streams without a backend.\n *\n * It owns its I/O — `chat()` — so `AparteDirectTransport` hands the request straight to\n * it; there is no wire format here to adapt. (This repository's own e2e keeps its\n * network mock on purpose: that suite tests the real wire path, which this provider\n * bypasses by construction.)\n *\n * ```ts\n * import { createScenarioProvider } from '@aparte/provider-scenario';\n * aparteGlobalConfig.registerAIProvider(createScenarioProvider({\n *   turns: ['Hello! Ask me anything.', [{ thinking: 'Let me see…' }, { text: 'Here is my answer.' }]],\n * }));\n * ```\n */\n\nimport type {\n    AparteAIModel,\n    AparteAIProvider,\n    AparteChatMessage,\n    AparteChatRequest,\n    AparteChatResponse,\n    AparteStreamEvent,\n    AparteUsage,\n} from '@aparte/core';\n\n// ─── What a turn is made of ──────────────────────────────────────────────────\n\n/** One thing the scripted model does, in order. */\nexport type ScenarioStep =\n    /** Stream this text, chunk by chunk at the configured pace. Markdown and `<artifact>` tags are fine: core parses them. */\n    | { text: string }\n    /** Stream this as reasoning (the thinking block). */\n    | { thinking: string }\n    /** Call a tool. The loop runs the registered handler, then calls the provider again with the result. */\n    | { tool: string; input?: Record<string, unknown>; id?: string }\n    /** Fail the turn with this message — what a provider error looks like to the UI. */\n    | { error: string }\n    /** Pause, in milliseconds — a slow model, a long tool. */\n    | { wait: number }\n    /** Override the usage reported at the end (merged over the estimate). */\n    | { usage: Partial<AparteUsage> };\n\n/** What the model does for ONE call. A bare string is one text step. */\nexport type ScenarioTurn = string | ScenarioStep[];\n\n/** A turn with the conditions under which it answers. */\nexport interface Scenario {\n    /**\n     * Answers when the last user message matches: a string is a case-insensitive\n     * substring, a RegExp is tested as is.\n     */\n    when?: string | RegExp;\n    /** Answers the call that follows this tool's result — the second half of a tool round-trip. */\n    after?: string;\n    turn: ScenarioTurn;\n}\n\n/** How fast text streams. */\nexport interface ScenarioPacing {\n    /** Characters per chunk. Default 12. */\n    chunk?: number;\n    /** Milliseconds between chunks. Default 24. */\n    delay?: number;\n}\n\nexport interface ScenarioProviderOptions {\n    /** Provider id, as seen by core (key resolution, model picker, events). Default `scenario`. */\n    id?: string;\n    /** Display name. Default `Scripted model`. */\n    name?: string;\n    /**\n     * Calls answered in order; the last one repeats. The simplest form — a demo that\n     * always goes the same way, a test that needs three replies. Every call to the\n     * model advances, a tool round-trip included.\n     */\n    turns?: ScenarioTurn[];\n    /**\n     * Named scenarios, one of which answers each call — picked by `match`, or by the\n     * default: the `after` of a tool result, else the first `when` that matches the\n     * last user message, else `default`, else the first one. A bare turn value is\n     * `{ turn }`.\n     */\n    scenarios?: Record<string, Scenario | ScenarioTurn>;\n    /** Picks the scenario for a call, by name. Return `undefined` to fall back to the default rule. */\n    match?: (request: AparteChatRequest, scenarios: Record<string, Scenario>) => string | undefined;\n    /** Typing pace, or `'instant'` for a test that wants the whole reply at once. */\n    pacing?: ScenarioPacing | 'instant';\n    /** The models the picker offers. Default: one, `scripted`, declaring streaming and tools. */\n    models?: AparteAIModel[];\n}\n\n// ─── Helpers ─────────────────────────────────────────────────────────────────\n\nconst textOf = (message: AparteChatMessage | undefined): string => {\n    if (!message) return '';\n    const { content } = message;\n    if (typeof content === 'string') return content;\n    return content.map((part) => (part.type === 'text' ? part.text : '')).join(' ');\n};\n\nconst stepsOf = (turn: ScenarioTurn): ScenarioStep[] => (typeof turn === 'string' ? [{ text: turn }] : turn);\n\nconst isTurn = (value: Scenario | ScenarioTurn): value is ScenarioTurn => typeof value === 'string' || Array.isArray(value);\n\nconst normalize = (scenarios: Record<string, Scenario | ScenarioTurn>): Record<string, Scenario> => {\n    const out: Record<string, Scenario> = {};\n    for (const [key, value] of Object.entries(scenarios)) out[key] = isTurn(value) ? { turn: value } : value;\n    return out;\n};\n\n/** The name of the tool a `tool_result` answers: the call with that id, in the turn before. */\nconst toolNameOf = (messages: AparteChatMessage[], toolCallId: string | undefined): string | undefined => {\n    for (let i = messages.length - 1; i >= 0; i--) {\n        const call = messages[i]!.toolCalls?.find((tc) => tc.id === toolCallId);\n        if (call) return call.name;\n    }\n    return undefined;\n};\n\n/**\n * The default rule: a tool result goes to the scenario that declared `after` for that\n * tool; otherwise the first scenario whose `when` matches the last user message;\n * otherwise `default`; otherwise the first scenario declared.\n */\nexport function defaultMatch(request: AparteChatRequest, scenarios: Record<string, Scenario>): string | undefined {\n    const entries = Object.entries(scenarios);\n    const last = request.messages[request.messages.length - 1];\n    if (last?.role === 'tool_result') {\n        const tool = toolNameOf(request.messages, last.toolCallId);\n        const hit = entries.find(([, s]) => s.after !== undefined && s.after === tool);\n        if (hit) return hit[0];\n    }\n    const text = textOf(last);\n    for (const [key, s] of entries) {\n        if (s.when === undefined) continue;\n        if (typeof s.when === 'string' ? text.toLowerCase().includes(s.when.toLowerCase()) : s.when.test(text)) return key;\n    }\n    if ('default' in scenarios) return 'default';\n    return entries[0]?.[0];\n}\n\nconst sleep = (ms: number, signal?: AbortSignal): Promise<void> => new Promise((resolve) => {\n    if (ms <= 0 || signal?.aborted) return resolve();\n    const timer = setTimeout(done, ms);\n    function done(): void {\n        clearTimeout(timer);\n        signal?.removeEventListener('abort', done);\n        resolve();\n    }\n    signal?.addEventListener('abort', done, { once: true });\n});\n\n/** Four characters per token — the usual rough cut, enough for a gauge to move. */\nconst estimateTokens = (chars: number): number => Math.ceil(chars / 4);\n\nlet sequence = 0;\n\n/**\n * Play one turn as the event stream the loop reads.\n *\n * Exported for a test or a tool that wants the events without a provider around them.\n */\nexport function playTurn(\n    turn: ScenarioTurn,\n    request: AparteChatRequest,\n    pacing: ScenarioPacing | 'instant' = {},\n    signal?: AbortSignal,\n): ReadableStream<AparteStreamEvent> {\n    const chunk = pacing === 'instant' ? Number.POSITIVE_INFINITY : Math.max(1, pacing.chunk ?? 12);\n    const delay = pacing === 'instant' ? 0 : Math.max(0, pacing.delay ?? 24);\n    const steps = stepsOf(turn);\n    const inputChars = request.messages.reduce((n, m) => n + textOf(m).length, 0);\n\n    return new ReadableStream<AparteStreamEvent>({\n        async start(controller) {\n            let outputChars = 0;\n            let usage: Partial<AparteUsage> = {};\n            // Not `startedAt`: that name is a segment stamp core writes in one place, and\n            // `check:segment-stamp` reads any write to it as a third stamping site.\n            const turnBegan = Date.now();\n            try {\n                for (const step of steps) {\n                    if (signal?.aborted) break;\n                    if ('wait' in step) {\n                        await sleep(step.wait, signal);\n                    } else if ('text' in step || 'thinking' in step) {\n                        const type = 'text' in step ? 'text' : 'thinking';\n                        const body = 'text' in step ? step.text : step.thinking;\n                        for (let i = 0; i < body.length; i += chunk) {\n                            if (signal?.aborted) break;\n                            const delta = body.slice(i, i + chunk);\n                            controller.enqueue({ type, delta });\n                            outputChars += delta.length;\n                            if (delay > 0 && i + chunk < body.length) await sleep(delay, signal);\n                        }\n                    } else if ('tool' in step) {\n                        controller.enqueue({ type: 'tool_use', id: step.id ?? `scenario_${++sequence}`, name: step.tool, input: step.input ?? {} });\n                    } else if ('error' in step) {\n                        controller.enqueue({ type: 'error', message: step.error });\n                        controller.close();\n                        return;\n                    } else if ('usage' in step) {\n                        usage = { ...usage, ...step.usage };\n                    }\n                }\n                if (!signal?.aborted) {\n                    const outputTokens = estimateTokens(outputChars);\n                    const inputTokens = estimateTokens(inputChars);\n                    controller.enqueue({\n                        type: 'done',\n                        usage: { inputTokens, outputTokens, totalTokens: inputTokens + outputTokens, durationMs: Date.now() - turnBegan, ...usage },\n                    });\n                }\n                controller.close();\n            } catch (err) {\n                controller.error(err);\n            }\n        },\n    });\n}\n\n// ─── The provider ────────────────────────────────────────────────────────────\n\n/**\n * Build the scripted provider. Register it like any other:\n *\n * ```ts\n * aparteGlobalConfig.registerAIProvider(createScenarioProvider({\n *   scenarios: {\n *     default: 'Ask me for a haiku, a table, or the weather.',\n *     haiku: { when: /haiku/i, turn: 'Web components hum —  \\nno framework in the wind,  \\njust the page, alive.' },\n *     weather: { when: 'weather', turn: [{ text: 'Let me check.' }, { tool: 'get_weather', input: { city: 'Lille' } }] },\n *     forecast: { after: 'get_weather', turn: 'Cloudy, 14 °C. Bring a jacket.' },\n *   },\n * }));\n * ```\n */\nexport function createScenarioProvider(options: ScenarioProviderOptions = {}): AparteAIProvider {\n    const id = options.id ?? 'scenario';\n    const name = options.name ?? 'Scripted model';\n    const models: AparteAIModel[] = options.models ?? [{\n        id: 'scripted',\n        name,\n        description: 'Replays scripted turns — no key, no network.',\n        capabilities: ['streaming', 'function_calling'],\n    }];\n    const scenarios = normalize(options.scenarios ?? {});\n    const match = options.match ?? defaultMatch;\n    let calls = 0;\n\n    const pick = (request: AparteChatRequest): ScenarioTurn => {\n        if (options.turns?.length) {\n            const turn = options.turns[Math.min(calls, options.turns.length - 1)]!;\n            calls++;\n            return turn;\n        }\n        const key = match(request, scenarios) ?? defaultMatch(request, scenarios);\n        const scenario = key !== undefined ? scenarios[key] : undefined;\n        return scenario?.turn ?? '';\n    };\n\n    return {\n        id,\n        getMetadata: () => ({\n            id,\n            name,\n            description: 'Replays scripted turns — no key, no network.',\n            isLocal: true,\n            configSchema: { fields: [] },\n        }),\n        getModels: () => models,\n        fetchModels: async () => models,\n        async chat(request: AparteChatRequest, _config?: unknown, ctx?: { providerId: string; signal?: AbortSignal }): Promise<AparteChatResponse> {\n            return playTurn(pick(request), request, options.pacing, ctx?.signal);\n        },\n    };\n}\n\nexport { showcase } from './presets.js';\n"],"names":[],"mappings":"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"}

package/dist/presets.d.ts

@@ -0,0 +1,15 @@
+import type { Scenario } from './index.js';
+/**
+ * A ready-made set of scenarios that shows the whole surface of a chat: markdown, a
+ * code block, reasoning, a tool round-trip, a typed question, an artifact, an error.
+ * The docs' live frames and a demo page can register it as is:
+ *
+ * ```ts
+ * aparteGlobalConfig.registerAIProvider(createScenarioProvider({ scenarios: showcase }));
+ * ```
+ *
+ * The tool names it calls — `get_weather`, `ask_user` — only do something if the app
+ * registered a tool of that name; `@aparte/plugin-ask-user` provides the second.
+ */
+export declare const showcase: Record<string, Scenario>;
+//# sourceMappingURL=presets.d.ts.map

package/dist/presets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"presets.d.ts","sourceRoot":"","sources":["../src/presets.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAsE7C,CAAC"}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@aparte/provider-scenario",
+  "version": "0.14.0",
+  "description": "A scripted model for aparté — replays turns you wrote (text at a typing pace, thinking, tool calls, errors) so demos, docs and your own tests stream real-looking conversations with no key and no network.",
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "@aparte-workspace/source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "peerDependencies": {
+    "@aparte/core": ">=0.14.0 <1.0.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.4.0",
+    "vite": "^6.0.0",
+    "@aparte/core": "0.14.0"
+  },
+  "keywords": [
+    "aparte",
+    "ai",
+    "provider",
+    "chat",
+    "scenario",
+    "mock",
+    "testing",
+    "demo",
+    "llm"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/apartejs/aparte.git",
+    "directory": "packages/providers/ai/scenario"
+  },
+  "bugs": {
+    "url": "https://github.com/apartejs/aparte/issues"
+  },
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build && tsc -b --emitDeclarationOnly --force",
+    "preview": "vite preview",
+    "test": "vitest",
+    "test:run": "vitest run",
+    "test:coverage": "vitest run --coverage"
+  }
+}