@alia.onl/sdk 22.3.0 → 22.4.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @alia.onl/sdk
 
+## 22.4.0
+
+- **A shared conversation shows its artifacts.** `readSharedConversation` keeps an assistant
+  message's `artifacts` (`AliaSharedArtifact`: `{ id, type, title, data }`, the canvas tool's
+  result) and `sharedMessages` hands each to the thread as the canvas call that drew it.
+  `AliaSharedConversation` draws them inline under their reply on the canvas renderers (reports,
+  decks, dashboards, charts, tables). An `AliaThread` that is not `readOnly` is unchanged: in the
+  app an artifact still opens in the canvas panel, not in the reply.
+- The server sends `artifacts` only from the API that ships with this release
+  (`docs/agent-embedding.md` §6); against an older API the shared page shows words and images,
+  as before.
+
 ## 22.3.0
 
 - **Decks and dashboards on the canvas.** `CanvasComponent` draws the canvas tool's two new

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alia.onl/sdk",
-  "version": "22.3.0",
+  "version": "22.4.0",
   "description": "Alia AI chat SDK — the conversation runtime, chat UI, voice calls and dictation for Oxy apps",
   "main": "src/index.ts",
   "react-native": "src/index.ts",

package/src/components/AliaSharedConversation.tsx

@@ -1,8 +1,9 @@
 /**
  * A conversation somebody shared (`GET /v1/shared/:token`, `docs/agent-embedding.md` §6), read
  * by anybody with the link, signed in or not. It is the SDK's own thread (`AliaThread`), read-only:
- * words, pictures and who wrote them — the server never sends a tool's output, which can hold the
- * person's own data — and nothing to vote on, play, edit or regenerate.
+ * words, pictures, who wrote them and the canvas artifacts Alia drew (a report, deck or dashboard,
+ * drawn inline because there is no canvas panel here). The server sends no other tool's output,
+ * which can hold the person's own data, and there is nothing to vote on, play, edit or regenerate.
  */
 
 import { AgentAvatarProvider } from '@oxy.so/bloom/agent-avatar';

package/src/components/thread/ThreadRow.tsx

@@ -24,6 +24,7 @@ import { readAgentCharacter } from '../../lib/agent-character';
 import { getImagesFromContent, messageText } from '../../lib/content-utils';
 import { ANCHORS, useAliaFlights } from '../../lib/flights';
 import { useLabels } from '../../lib/labels';
+import { canvasResultOf } from '../../lib/canvas-result';
 import { askedQuestions, isQuestionInvocation } from '../../lib/questions';
 import { parseCatalogueTool, useToolRenderers } from '../../lib/tool-renderers';
 import { isWebInvocation, taskListLog, webSearchLog } from '../../lib/work-log';
@@ -33,6 +34,7 @@ import type { OpenThought } from '../../hooks/useOpenThought';
 import { Image } from '../Image';
 import { PlanPreviewCard } from '../PlanPreviewCard';
 import { AskedQuestions } from '../QuestionCard';
+import { CanvasComponent } from '../canvas/CanvasComponent';
 import { ReplyMarkdown } from '../ReplyMarkdown';
 import { MessageBlockBoundary } from './MessageBlockBoundary';
 import { ToolResultCard } from './ToolResultCard';
@@ -240,7 +242,20 @@ function ReplyTurn({
       },
     ];
   });
-  const renderedCalls = new Set(rendered.map(({ call }) => call));
+
+  // A shared conversation has no canvas panel to open an artifact in, so it draws each one inline.
+  const inlineCanvases = readOnly
+    ? toolInvocations.flatMap((call, index) => {
+        const canvas = canvasResultOf(call);
+        return canvas === null
+          ? []
+          : [{ key: call.toolCallId || `canvas-${message.id}-${index}`, call, canvas }];
+      })
+    : [];
+  const renderedCalls = new Set([
+    ...rendered.map(({ call }) => call),
+    ...inlineCanvases.map(({ call }) => call),
+  ]);
 
   // The calls the work summary lists: every one that did not draw its own card. Read on each
   // render — the list changes per streamed tool event and the row is memoised on `message`.
@@ -320,6 +335,7 @@ function ReplyTurn({
     hasWorkLog ||
     toolCards.length > 0 ||
     rendered.length > 0 ||
+    inlineCanvases.length > 0 ||
     (message.isStreaming === true && message.source === 'voice');
   /** Its avatar is the source of the flight into the header while it is answering. */
   const agentLive = agent !== undefined && message.isStreaming === true;
@@ -420,6 +436,13 @@ function ReplyTurn({
               {rendered.map(({ key, node }) => (
                 <MessageBlockBoundary key={key}>{node}</MessageBlockBoundary>
               ))}
+              {inlineCanvases.map(({ key, canvas }) => (
+                <MessageBlockBoundary key={key}>
+                  <View className="rounded-2xl border border-border p-4" testID="shared-canvas">
+                    <CanvasComponent component={{ id: key, ...canvas }} />
+                  </View>
+                </MessageBlockBoundary>
+              ))}
               {/* Each card in its own boundary: `cardOf` checks the card's NAME, and its data is
                   cast unchecked. */}
               {toolCards.map(({ key, card }) => (

package/src/lib/canvas-result.ts

@@ -0,0 +1,21 @@
+import type { ToolInvocation } from '../runtime/types';
+
+/** A canvas artifact as `CanvasComponent` draws it. */
+export interface CanvasResult {
+  type: string;
+  title: string;
+  data: unknown;
+}
+
+/**
+ * A finished canvas call's artifact; `null` for any other call, one still running, or one the tool
+ * refused (`{ error }`). An artifact without a title is titled by its type.
+ */
+export function canvasResultOf(call: ToolInvocation): CanvasResult | null {
+  if (call.toolName !== 'canvas' || call.state !== 'result') return null;
+  const result: unknown = call.result;
+  if (result === null || typeof result !== 'object') return null;
+  const { type, title, data } = result as Record<string, unknown>;
+  if (typeof type !== 'string' || type === '' || data === undefined || data === null) return null;
+  return { type, title: typeof title === 'string' && title !== '' ? title : type, data };
+}

package/src/runtime/sharing.ts

@@ -5,7 +5,7 @@ import { useAliaApi } from './api';
 import { useAliaRuntime } from './config';
 import { aliaQueryKeys } from './query-keys';
 import { API_ROUTES } from './routes';
-import type { Message } from './types';
+import type { Message, ToolInvocation } from './types';
 
 /** A conversation's read-only link (`POST /v1/conversations/:id/share`, `docs/agent-embedding.md` §6). */
 export interface AliaConversationShare {
@@ -65,11 +65,26 @@ export function useShareConversation() {
   );
 }
 
-/** A message of a shared conversation: words and pictures, and who wrote them. Never a tool's output. */
+/**
+ * A canvas artifact of a shared conversation: the report, deck, dashboard, chart or table Alia drew,
+ * as the canvas tool returned it. `id` is the tool call that drew it.
+ */
+export interface AliaSharedArtifact {
+  id: string;
+  type: string;
+  title: string;
+  data: unknown;
+}
+
+/**
+ * A message of a shared conversation: words and pictures, who wrote them, and the canvas artifacts
+ * it drew. Never any other tool's output.
+ */
 export interface AliaSharedMessage {
   role: 'user' | 'assistant';
   content: string | Array<{ type: string; [key: string]: unknown }>;
   agent?: AliaSharedAgent;
+  artifacts?: AliaSharedArtifact[];
 }
 
 export interface AliaSharedAgent {
@@ -100,6 +115,18 @@ function readSharedAgent(value: unknown): AliaSharedAgent | undefined {
   };
 }
 
+/** The artifacts the server sent, each kept only with an id, a type, a title and its data. */
+function readSharedArtifacts(value: unknown): AliaSharedArtifact[] {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((artifact): AliaSharedArtifact[] => {
+    if (artifact === null || typeof artifact !== 'object') return [];
+    const { id, type, title, data } = artifact as Record<string, unknown>;
+    if (typeof id !== 'string' || typeof type !== 'string' || type === '') return [];
+    if (data === undefined || data === null) return [];
+    return [{ id, type, title: typeof title === 'string' ? title : '', data }];
+  });
+}
+
 /** The shared conversation as the contract names it; any message of another shape is left out. */
 export function readSharedConversation(value: unknown): AliaSharedConversationData | null {
   if (value === null || typeof value !== 'object') return null;
@@ -107,15 +134,17 @@ export function readSharedConversation(value: unknown): AliaSharedConversationDa
   if (!Array.isArray(raw.messages) || typeof raw.expiresAt !== 'string') return null;
   const messages = raw.messages.flatMap((message): AliaSharedMessage[] => {
     if (message === null || typeof message !== 'object') return [];
-    const { role, content, agent } = message as Record<string, unknown>;
+    const { role, content, agent, artifacts } = message as Record<string, unknown>;
     if (role !== 'user' && role !== 'assistant') return [];
     if (typeof content !== 'string' && !Array.isArray(content)) return [];
     const author = readSharedAgent(agent);
+    const drawn = role === 'assistant' ? readSharedArtifacts(artifacts) : [];
     return [
       {
         role,
         content: content as AliaSharedMessage['content'],
         ...(author ? { agent: author } : {}),
+        ...(drawn.length > 0 ? { artifacts: drawn } : {}),
       },
     ];
   });
@@ -128,13 +157,28 @@ export function readSharedConversation(value: unknown): AliaSharedConversationDa
   };
 }
 
-/** The shared messages as the thread draws them: an agent's under its own identity. */
+/**
+ * The shared messages as the thread draws them: an agent's under its own identity, and each artifact
+ * as the canvas call that drew it, which the read-only thread draws inline.
+ */
 export function sharedMessages(shared: AliaSharedConversationData): Message[] {
   return shared.messages.map((message, index) => ({
     id: `shared-${index}`,
     role: message.role,
     content: message.content,
     ...(message.agent ? { agentInfo: { ...message.agent } } : {}),
+    ...(message.artifacts
+      ? {
+          toolInvocations: message.artifacts.map(
+            (artifact): ToolInvocation => ({
+              toolCallId: artifact.id,
+              toolName: 'canvas',
+              state: 'result',
+              result: { type: artifact.type, title: artifact.title, data: artifact.data },
+            }),
+          ),
+        }
+      : {}),
   }));
 }