@datalayer/agent-runtimes 1.5.89 → 1.5.91

package/lib/components/teams/transcript/useSceneRecording.d.ts

@@ -0,0 +1,45 @@
+import type { SceneRecordingFile } from '../../../types/scenes';
+import type { SceneTranscriptLine, SceneTranscriptMember } from '../sceneTranscriptRules';
+import { type RecordedStage } from './recordingPlayback';
+/** How the recording is played. */
+export type SceneRecordingOptions = {
+    /** The members, by id and name, with their connections: for the graph's flows and calls. */
+    members: readonly SceneTranscriptMember[];
+    /** The member the audience talks to: the links the graph draws flowing start there. */
+    entry: string;
+    /** One beat's lines only, by its id; every line when unsaid. */
+    beat?: string;
+    /** Faster than recorded (2 is twice as fast); 1 when unsaid: the recorded pace. */
+    speed?: number;
+    /** The longest pause between two lines, in milliseconds; none when unsaid. */
+    maxGapMs?: number;
+    /** Start playing at once; true when unsaid. */
+    autoPlay?: boolean;
+    /** Start again from the first line once the last was shown, after `loopAfterMs`. */
+    loop?: boolean;
+    /** How long the last line stays before a loop starts again; 8 s when unsaid. */
+    loopAfterMs?: number;
+    /** How often the stage is drawn again while a message flows; 250 ms when unsaid. */
+    tickMs?: number;
+};
+/** A recording at a moment of its playback. */
+export type SceneRecordingPlayback = RecordedStage & {
+    /** The lines said so far, in order. */
+    lines: SceneTranscriptLine[];
+    /** Every line of what is played: the beat's, or the whole recording's. */
+    all: SceneTranscriptLine[];
+    /** *Recording, taken 29 October 2026*. */
+    label: string;
+    /** When it was taken, as the recording says it. */
+    taken: string;
+    /** What the audience is told of it, when the recording says. */
+    note?: string;
+    playing: boolean;
+    /** Every line was shown. */
+    done: boolean;
+    play: () => void;
+    pause: () => void;
+    restart: () => void;
+};
+/** Plays a scene's recording at its recorded pace; nothing to play when there is none. */
+export declare function useSceneRecording(recording: SceneRecordingFile | undefined, { members, entry, beat, speed, maxGapMs, autoPlay, loop, loopAfterMs, tickMs, }: SceneRecordingOptions): SceneRecordingPlayback;

package/lib/components/teams/transcript/useSceneRecording.js

@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * A scene's recording, played: when a stage cannot play live, its recording
+ * (`SceneRecordingFile`, `SCENE_RECORDINGS` in `specs/sceneRecordings`)
+ * plays at the pace it was recorded. The hook hands the page what to draw
+ * at each moment — the lines said so far for `TranscriptViews`, the
+ * `flows` and `calls` for `A2ATeamGraph`, and the label, *Recording, taken
+ * <date>* — and the controls: play, pause, restart.
+ *
+ * ```tsx
+ * const played = useSceneRecording(getSceneRecording(scene.id), { members, entry });
+ * <RecordingLabel taken={played.taken} />
+ * <A2ATeamGraph … flows={played.flows} calls={played.calls} />
+ * <TranscriptViews lines={played.lines} members={members} />
+ * ```
+ *
+ * A line of a recording has no span: the drill-down says so.
+ *
+ * @module components/teams/transcript/useSceneRecording
+ */
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { playbackOffsets, recordedLinesOf, recordedMomentAt, recordedStageAt, recordingLabel, } from './recordingPlayback.js';
+const now = () => typeof performance !== 'undefined' ? performance.now() : Date.now();
+/** Plays a scene's recording at its recorded pace; nothing to play when there is none. */
+export function useSceneRecording(recording, { members, entry, beat, speed = 1, maxGapMs, autoPlay = true, loop = false, loopAfterMs = 8000, tickMs = 250, }) {
+    const all = useMemo(() => (recording ? recordedLinesOf(recording, beat) : []), [recording, beat]);
+    const offsets = useMemo(() => playbackOffsets(all, { speed, maxGapMs }), [all, speed, maxGapMs]);
+    const [elapsed, setElapsed] = useState(0);
+    const [playing, setPlaying] = useState(autoPlay && all.length > 0);
+    // Where the clock started, minus what was played before a pause.
+    const started = useRef(now());
+    const total = offsets.length ? offsets[offsets.length - 1] : 0;
+    useEffect(() => {
+        setElapsed(0);
+        started.current = now();
+        setPlaying(autoPlay && all.length > 0);
+    }, [all, autoPlay]);
+    useEffect(() => {
+        if (!playing) {
+            return undefined;
+        }
+        const timer = setInterval(() => {
+            const at = now() - started.current;
+            if (at >= total + (loop ? loopAfterMs : 0)) {
+                if (loop) {
+                    started.current = now();
+                    setElapsed(0);
+                    return;
+                }
+                setElapsed(total);
+                setPlaying(false);
+                return;
+            }
+            setElapsed(at);
+        }, tickMs);
+        return () => clearInterval(timer);
+    }, [playing, total, loop, loopAfterMs, tickMs]);
+    const play = useCallback(() => {
+        if (all.length === 0) {
+            return;
+        }
+        started.current = now() - (elapsed >= total ? 0 : elapsed);
+        if (elapsed >= total) {
+            setElapsed(0);
+        }
+        setPlaying(true);
+    }, [all.length, elapsed, total]);
+    const pause = useCallback(() => setPlaying(false), []);
+    const restart = useCallback(() => {
+        started.current = now();
+        setElapsed(0);
+        setPlaying(all.length > 0);
+    }, [all.length]);
+    const shown = offsets.filter(offset => offset <= elapsed).length;
+    const lines = useMemo(() => all.slice(0, shown), [all, shown]);
+    const stage = useMemo(() => all.length
+        ? recordedStageAt(all, recordedMomentAt(all, offsets, elapsed, speed), members, entry)
+        : { flows: {}, calls: [] }, [all, offsets, elapsed, speed, members, entry]);
+    const taken = recording?.taken ?? '';
+    return {
+        ...stage,
+        lines,
+        all,
+        label: recordingLabel(taken),
+        taken,
+        ...(recording?.note ? { note: recording.note } : {}),
+        playing,
+        done: all.length > 0 && shown === all.length && !playing,
+        play,
+        pause,
+        restart,
+    };
+}

package/lib/examples/ScenesExample.js

@@ -37,7 +37,7 @@ import { ThemedProvider } from './utils/themedProvider.js';
 import { useBrowserInference } from '../hooks/useBrowserInference.js';
 import { useAnonymousSessionStore } from '../runtimes/browser/anonymousToken.js';
 import { connectA2APeer } from '../runtimes/browser/a2aPeer.js';
-import { A2ATeamGraph, NOTEBOOK_AND_WORDS, PERSON, SceneView, sceneCuesOf, sceneMemberUrl, sceneRuntimePorts, sceneStageOf, teamConnectionsOf, teamToolClassifier, useA2ATeam, } from '../components/teams/index.js';
+import { A2ATeamGraph, NOTEBOOK_AND_WORDS, PERSON, SceneView, sceneCuesOf, sceneMemberUrl, sceneRuntimePorts, sceneStageOf, teamConnectionsOf, teamToolClassifier, useA2ATeam, useSceneTranscript, latestLineOnEdge, selectedEdgeOf, selectionOfLine, stageBackdropOf, } from '../components/teams/index.js';
 import { listSceneSpecs } from '../specs/scenes.js';
 import { classifyToolCall, traceA2AFetch, useAgentInspector, } from '../components/inspector/index.js';
 /** Where the members on a runtime are, by application id: the local ports, unless a variable says. */
@@ -151,6 +151,11 @@ function Scene({ scene }) {
         name: member.app.name,
         connections: runtimeMembers.find(one => one.id === member.id)?.connections ?? [],
     })), [stage, runtimeMembers]);
+    // The exchange selected in the transcript, as the edge of the graph it is
+    // on (S3-02): the graph draws it with a halo; a click on an edge selects
+    // its latest exchange.
+    const [selectedEdge, setSelectedEdge] = useState(null);
+    const lines = useSceneTranscript(inspector, transcriptMembers);
     const whereOf = (member) => member.runsIn === 'browser'
         ? 'in your browser'
         : `on a runtime, ${new URL(runtimeMembers.find(one => one.id === member.id)?.url ?? 'http://runtime').host}`;
@@ -173,7 +178,7 @@ function Scene({ scene }) {
     return (_jsxs(Box, { "data-scene-example": scene.id, children: [_jsx(Text, { as: "p", sx: { color: 'fg.muted', mt: 0 }, "data-scene-assumes": "", children: stage.assumes }), anonymous.status === 'active' && anonymous.expiresAt && (_jsx(Box, { mb: 3, children: _jsx(AnonymousKeyTimer, { expiresAt: anonymous.expiresAt, grantedMs: anonymous.grantedMs, label: `${entry.app.name}'s trial key`, onExpire: () => useAnonymousSessionStore.getState().expire() }) })), anonymous.status === 'expired' && (_jsx(Box, { mb: 3, children: _jsx(AnonymousKeyExpired, { agentName: entry.app.name, onSignedIn: () => useAnonymousSessionStore.getState().clear() }) })), entryInBrowser && needsSignIn && (_jsxs(Flash, { variant: "warning", sx: { mb: 3 }, children: [entry.app.name, " asks its model through the Datalayer inference service: sign in, or wait for a visitor\u2019s trial key."] })), notReached.map(member => (_jsx(Flash, { variant: "danger", sx: { mb: 3 }, "data-scene-needs": member.app.id, children: memberNeeds(member, reachedOf(member.id).error ?? '').map(line => (_jsx(Text, { as: "p", sx: { m: 0 }, children: line }, line))) }, member.id))), runtimeMembers.map(member => (_jsx(ReachMember, { member: member, 
                 // Its requests are the entry's, or the person's own when the
                 // page asks it itself.
-                asker: member.entry ? PERSON : entry.app.name, tracer: inspector, onReached: onReached }, member.id))), _jsx(Box, { border: "1px solid", borderColor: "border.default", borderRadius: 2, bg: "canvas.subtle", px: 2, pt: 2, mb: 3, children: _jsx(SceneView, { members: transcriptMembers, tracer: inspector, emptyText: `Nothing said yet: ask ${entry.app.name} with one of the suggestions.`, children: _jsx(A2ATeamGraph, { entry: {
+                asker: member.entry ? PERSON : entry.app.name, tracer: inspector, onReached: onReached }, member.id))), _jsx(Box, { border: "1px solid", borderColor: "border.default", borderRadius: 2, bg: "canvas.subtle", px: 2, pt: 2, mb: 3, children: _jsx(SceneView, { members: transcriptMembers, tracer: inspector, onSelect: selection => setSelectedEdge(selectedEdgeOf(selection, transcriptMembers) ?? null), emptyText: `Nothing said yet: ask ${entry.app.name} with one of the suggestions.`, children: _jsx(A2ATeamGraph, { entry: {
                             id: entry.app.id,
                             name: entry.app.name,
                             emoji: entry.cast.persona.face || entry.app.emoji,
@@ -228,7 +233,15 @@ function Scene({ scene }) {
                             ];
                         })), 
                         // Room for the balloons: suggestions, *more* and a notebook.
-                        balloonRoom: 320 }) }) }), _jsx(Box, { ref: notebookArea, mb: team.notebook ? 3 : 0, "data-team-notebook-placement": "under-graph" }), _jsxs(Box, { display: "flex", gap: 3, flexWrap: "wrap", children: [_jsxs(Box, { flex: "1 1 420px", minWidth: 0, children: [_jsxs(Heading, { as: "h3", sx: { fontSize: 2, mb: 2 }, children: ["Ask ", entry.app.name] }), _jsx(Text, { as: "p", sx: { color: 'fg.muted', fontSize: 1, mt: 0 }, children: "Or choose one of its suggestions in its balloon: the script\u2019s cues." }), _jsx(Textarea, { ref: composer, block: true, rows: 3, value: draft, placeholder: suggestions[0]?.prompt ?? 'Ask…', onChange: event => setDraft(event.target.value), onKeyDown: event => {
+                        balloonRoom: 320, 
+                        // Drawn as the scene says: studio, hero or plain.
+                        backdrop: stageBackdropOf(scene), selected: selectedEdge, onSelectEdge: edge => {
+                            const line = latestLineOnEdge(edge, lines, transcriptMembers);
+                            setSelectedEdge(line
+                                ? (selectedEdgeOf(selectionOfLine(line), transcriptMembers) ??
+                                    null)
+                                : null);
+                        } }) }) }), _jsx(Box, { ref: notebookArea, mb: team.notebook ? 3 : 0, "data-team-notebook-placement": "under-graph" }), _jsxs(Box, { display: "flex", gap: 3, flexWrap: "wrap", children: [_jsxs(Box, { flex: "1 1 420px", minWidth: 0, children: [_jsxs(Heading, { as: "h3", sx: { fontSize: 2, mb: 2 }, children: ["Ask ", entry.app.name] }), _jsx(Text, { as: "p", sx: { color: 'fg.muted', fontSize: 1, mt: 0 }, children: "Or choose one of its suggestions in its balloon: the script\u2019s cues." }), _jsx(Textarea, { ref: composer, block: true, rows: 3, value: draft, placeholder: suggestions[0]?.prompt ?? 'Ask…', onChange: event => setDraft(event.target.value), onKeyDown: event => {
                                     if (event.key === 'Enter' && !event.shiftKey) {
                                         event.preventDefault();
                                         send(draft);

package/lib/portable/hosts/agentClient.d.ts

@@ -20,6 +20,12 @@ export type HostTurnRequest<P> = Readonly<{
      * another application): a new session's uid is derived with it.
      */
     sessionGeneration?: number;
+    /**
+     * The host user never linked: exchanged as a visitor, which ai-agents
+     * answers only when the installation's owner opened it to visitors and the
+     * deployment opens to somebody signed out (WHATSAPP WA-03).
+     */
+    visitor?: boolean;
 }>;
 export type TurnStream = Readonly<{
     /**
@@ -111,6 +117,8 @@ export declare class HostKeyCredentials<P> implements HostCredentials<P> {
         hostKey: string;
         /** Where the turn is asked from: Datalayer refuses a denied channel at once. */
         place?: Place;
+        /** As a visitor: the host user never linked (WHATSAPP WA-03). */
+        visitor?: boolean;
     }): Promise<HostExchange>;
     forTurn(request: HostTurnRequest<P>): Promise<HostSession>;
 }

package/lib/portable/hosts/agentClient.js

@@ -44,6 +44,7 @@ export class HostKeyCredentials {
             externalUserId: request.externalUserId,
             hostKey,
             place: this.shape.placeOf(request),
+            ...(request.visitor ? { visitor: true } : {}),
         });
     }
     /** The exchange for one host user and deployment, with a key in hand (a delivery, an action). */
@@ -53,6 +54,7 @@ export class HostKeyCredentials {
                 deployment_uid: input.deploymentUid,
                 external_user_id: input.externalUserId,
                 ...(input.place ? { place: input.place } : {}),
+                ...(input.visitor ? { visitor: true } : {}),
             }),
             headers: {
                 'content-type': 'application/json',

package/lib/portable/hosts/approvalRenderers.d.ts

@@ -6,7 +6,9 @@ import type { ApprovalPresentation } from './contracts';
  * presented is named by the renderer, or the card fails closed. An unknown
  * tool, an argument the renderer does not know, an attachment, and every
  * action that is not mail (reads, writes, other sends, destructive, financial,
- * publishing, executing) are reviewed in Datalayer (decided by the user on 16 October 2026: mail only).
+ * publishing, executing) are reviewed in Datalayer (decided by the user on 16 October 2026: mail only),
+ * but for a company's `pap_confirm`, decided in a host with the operation's
+ * exact revision since 28 October 2026 (the user, WHATSAPP WA-43).
  * They render ai-agents' presentation v1, a different input
  * from `../approvals.ts` and `../approvalCard.ts`. Moved from the Slack
  * service (DC-004).
@@ -39,7 +41,13 @@ type Renderer = Readonly<{
 export declare const DATALAYER_ONLY: Set<"unknown" | "read" | "write" | "send" | "delete" | "publish" | "execute" | "financial">;
 /** The words of a tool's name that make a send mail: contracts.json `mail_words`. */
 export declare const MAIL_WORDS: ReadonlySet<string>;
-/** The renderers, the first that matches wins: Datalayer-only before any other. */
+export declare const isPapConfirm: (toolName: string) => boolean;
+/** What a `pap_confirm` approval carries: contracts.json `presentation.pap_confirm_keys`. */
+export declare const PAP_CONFIRM_KEYS: readonly ["key", "company", "summary", "terms", "operation_ref", "revision", "digest", "class", "session", "only_the_person", "was"];
+/**
+ * The renderers, the first that matches wins: a company's `pap_confirm`
+ * (whose name says no class), then Datalayer-only before any other.
+ */
 export declare const RENDERERS: readonly Renderer[];
 /**
  * How a host shows an approval, by the renderer that knows its tool; with

package/lib/portable/hosts/approvalRenderers.js

@@ -98,6 +98,82 @@ const mail = {
         return rendered('mail', presentation, fields, MAIL_KEYS, extra);
     },
 };
+/** `pap_confirm`, as the gateway names it with or without a prefix. */
+const PAP_CONFIRM = /(^|[_.:\-/])pap_confirm$/;
+export const isPapConfirm = (toolName) => PAP_CONFIRM.test(toolName);
+/** What a `pap_confirm` approval carries: contracts.json `presentation.pap_confirm_keys`. */
+export const PAP_CONFIRM_KEYS = [
+    'key',
+    'company',
+    'summary',
+    'terms',
+    'operation_ref',
+    'revision',
+    'digest',
+    'class',
+    'session',
+    'only_the_person',
+    'was',
+];
+/**
+ * A company's operation the person confirms (WHATSAPP WA-43, decided by the
+ * user 28 October 2026): the company, its own summary, every term, the
+ * operation and its **exact revision** — a decision is on that revision and
+ * no other; a changed revision is another approval. A missing company,
+ * summary, operation, revision or digest fails the card closed.
+ */
+const papConfirm = {
+    name: 'pap-confirm',
+    matches: presentation => isPapConfirm(presentation.tool_name),
+    render(presentation) {
+        const args = presentation.arguments;
+        const fields = [];
+        const missing = [];
+        const extra = [];
+        const company = typeof args.company === 'string' ? args.company : '';
+        const summary = typeof args.summary === 'string' ? args.summary : '';
+        const operation = typeof args.operation_ref === 'string' ? args.operation_ref : '';
+        const revision = Number.isInteger(args.revision)
+            ? args.revision
+            : undefined;
+        if (!company)
+            missing.push('the company');
+        else
+            fields.push({ label: 'Company', value: company });
+        if (!summary)
+            missing.push('what it does, in its words');
+        else
+            fields.push({ label: 'Summary', value: summary });
+        const termsAreFields = args.terms === undefined ||
+            args.terms === null ||
+            (typeof args.terms === 'object' && !Array.isArray(args.terms));
+        if (!termsAreFields)
+            extra.push('Its terms are not named one by one: review it in Datalayer.');
+        else
+            for (const [name, value] of Object.entries((args.terms ?? {})))
+                fields.push({ label: name, value: text(value) });
+        if (!operation)
+            missing.push('the operation');
+        else
+            fields.push({ label: 'Operation', value: operation });
+        if (revision === undefined)
+            missing.push('its exact revision');
+        else
+            fields.push({ label: 'Revision', value: String(revision) });
+        if (typeof args.digest !== 'string' || !args.digest)
+            missing.push('the digest of its terms');
+        if (typeof args.class === 'string' && args.class)
+            fields.push({ label: 'What it does', value: args.class });
+        const was = args.was && typeof args.was === 'object'
+            ? args.was
+            : undefined;
+        if (was && was.revision !== undefined)
+            fields.push({ label: 'Replaces revision', value: text(was.revision) });
+        if (missing.length)
+            extra.push(`The request does not say ${missing.join(', ')}: review it in Datalayer.`);
+        return rendered('pap-confirm', presentation, fields, PAP_CONFIRM_KEYS, extra);
+    },
+};
 /** Everything but mail: shown, decided only in Datalayer. */
 const datalayerOnly = {
     name: 'datalayer-only',
@@ -122,8 +198,11 @@ const datalayerOnly = {
         };
     },
 };
-/** The renderers, the first that matches wins: Datalayer-only before any other. */
-export const RENDERERS = [datalayerOnly, mail];
+/**
+ * The renderers, the first that matches wins: a company's `pap_confirm`
+ * (whose name says no class), then Datalayer-only before any other.
+ */
+export const RENDERERS = [papConfirm, datalayerOnly, mail];
 /**
  * How a host shows an approval, by the renderer that knows its tool; with
  * none, nothing is decided in the host.

package/lib/portable/hosts/contracts.d.ts

@@ -93,6 +93,7 @@ export declare const exchangeSchema: z.ZodObject<{
     expires_in: z.ZodNumber;
     exp: z.ZodNumber;
     principal_uid: z.ZodString;
+    visitor: z.ZodOptional<z.ZodBoolean>;
     host_uid: z.ZodString;
     deployment: z.ZodObject<{
         uid: z.ZodString;

package/lib/portable/hosts/contracts.js

@@ -104,6 +104,8 @@ export const exchangeSchema = z.object({
     expires_in: z.number().int().nonnegative(),
     exp: z.number().int(),
     principal_uid: z.string().min(1),
+    /** A person who never linked, answered as a visitor (WHATSAPP WA-03): `principal_uid` is `visitor:<hash>`. */
+    visitor: z.boolean().optional(),
     host_uid: z.string().min(1),
     deployment: z.object({
         uid: z.string().min(1),

package/lib/portable/hosts/contracts.json

@@ -114,6 +114,45 @@
       "direct"
     ]
   },
+  "visitor_exchange": {
+    "about": "WHATSAPP WA-03 (decided 28 October 2026): a host's user who never linked, answered as a visitor when the installation's owner turned its visitors switch on and the deployment opens to somebody signed out. sub is visitor:<hash of the host's id with the installation's salt>; no link; a daily cap per visitor at the exchange (429).",
+    "request": {
+      "external_user_id": "US.13491208655302741918",
+      "deployment_uid": "dep-1",
+      "visitor": true
+    },
+    "response_keys": [
+      "success",
+      "access_token",
+      "token_type",
+      "expires_in",
+      "exp",
+      "principal_uid",
+      "visitor",
+      "host_uid",
+      "deployment",
+      "session_api"
+    ],
+    "token_claims": [
+      "jti",
+      "iss",
+      "iat",
+      "exp",
+      "aud",
+      "sub",
+      "azp",
+      "host_kind",
+      "deployment_uid",
+      "app_uid",
+      "visitor",
+      "scope"
+    ],
+    "sub_prefix": "visitor:",
+    "refusals": {
+      "visitors_off": 403,
+      "capped": 429
+    }
+  },
   "whoami": {
     "response_keys": [
       "success",
@@ -124,7 +163,8 @@
       "app_uid",
       "link",
       "scope",
-      "expires_in"
+      "expires_in",
+      "visitor"
     ]
   },
   "bind_session": {
@@ -328,7 +368,21 @@
       "host_may_decide": true,
       "reasons": [],
       "digest": "0000000000000000000000000000000000000000000000000000000000000000"
-    }
+    },
+    "pap_confirm_keys": [
+      "key",
+      "company",
+      "summary",
+      "terms",
+      "operation_ref",
+      "revision",
+      "digest",
+      "class",
+      "session",
+      "only_the_person",
+      "was"
+    ],
+    "pap_confirm_about": "WHATSAPP WA-43 (decided 28 October 2026): a company's pap_confirm (any gateway prefix) is decided in a host, on its exact revision; every other non-mail action stays in Datalayer."
   },
   "decision": {
     "request": {

package/lib/specs/actions.js

@@ -788,6 +788,7 @@ export const APP_BEHAVIOURS = {
         'earthdata.search_earth_datagranules': 'do_it',
         'earthdata.search_earth_datasets': 'do_it',
     },
+    'code-explainer': {},
     'crop-monitoring': {
         'earthdata.download_earth_data_granules': 'leave_to_me',
         'earthdata.search_earth_datagranules': 'do_it',
@@ -1011,6 +1012,7 @@ export const APP_ESCALATIONS = {
     accounting: {},
     'bookkeeping-desk': {},
     'change-detection': {},
+    'code-explainer': {},
     'crop-monitoring': {},
     'customer-interview': {},
     'data-quality': {},

package/lib/specs/apps.d.ts

@@ -11,6 +11,7 @@ import type { AppBuilt, AppKind, AppSpec } from '../types/agentspecs';
 export declare const ACCOUNTING_APP_0_0_2: AppSpec;
 export declare const BOOKKEEPING_DESK_APP_0_0_2: AppSpec;
 export declare const CHANGE_DETECTION_APP_0_0_2: AppSpec;
+export declare const CODE_EXPLAINER_APP_0_0_1: AppSpec;
 export declare const CROP_MONITORING_APP_0_0_2: AppSpec;
 export declare const CUSTOMER_INTERVIEW_APP_0_0_3: AppSpec;
 export declare const DATA_QUALITY_APP_0_0_3: AppSpec;