@axiom-lattice/protocols 4.1.3 → 4.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axiom-lattice/protocols",
-  "version": "4.1.3",
+  "version": "4.1.4",
   "description": "Unified protocol type definitions for Axiom Lattice framework",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

package/src/AgentWebAppRuntimeProtocol.ts

@@ -1,6 +1,7 @@
 import type {
   AgentWebAppAppearance,
   AgentWebAppFeatures,
+  AgentWebAppIdentityAssurance,
 } from "./AgentWebAppStoreProtocol";
 
 /** Server-owned metadata that isolates an external user's Web App thread. */
@@ -63,7 +64,7 @@ export interface AgentWebAppBootstrap {
     defaultModelKey?: string;
     features: AgentWebAppFeatures;
     appearance: AgentWebAppAppearance;
-    identityAssurance: "unverified";
+    identityAssurance: AgentWebAppIdentityAssurance;
   };
   projects: Array<{
     id: string;

package/src/AgentWebAppStoreProtocol.ts

@@ -17,6 +17,8 @@ export interface AgentWebAppFeatures {
   attachments: boolean;
   hitl: boolean;
   genUI: boolean;
+  /** File panel surface. Tolerated missing (treated as false) for records created before Phase 2. */
+  files?: boolean;
 }
 
 /** Optional display customization for an Agent Web App. */
@@ -26,6 +28,31 @@ export interface AgentWebAppAppearance {
   primaryColor?: string;
 }
 
+/** Identity assurance levels reported by the runtime. */
+export type AgentWebAppIdentityAssurance = "unverified" | "verified";
+
+/** How external callers may identify themselves for this web app. */
+export type AgentWebAppIdentityPolicy = "unverified" | "verified" | "both";
+
+/** One trusted issuer entry. `secret` pairs with HS256, `jwksUrl` with RS256. */
+export interface AgentWebAppIssuerConfig {
+  /** Exact `iss` claim match. */
+  iss: string;
+  /** Exact `aud` claim match; conventionally the webAppId. */
+  aud: string;
+  alg: "HS256" | "RS256";
+  /** Shared secret for HS256. */
+  secret?: string;
+  /** JWKS endpoint URL for RS256. */
+  jwksUrl?: string;
+}
+
+/** Identity configuration block for a web app. Absent = V1 unverified behavior. */
+export interface AgentWebAppIdentityConfig {
+  policy: AgentWebAppIdentityPolicy;
+  issuers: AgentWebAppIssuerConfig[];
+}
+
 /** Persisted React SDK publication of an assistant. */
 export interface AgentWebApp {
   id: string;
@@ -40,6 +67,7 @@ export interface AgentWebApp {
   scope: AgentWebAppScope;
   features: AgentWebAppFeatures;
   appearance: AgentWebAppAppearance;
+  identity?: AgentWebAppIdentityConfig;
   createdAt: Date;
   updatedAt: Date;
 }
@@ -55,6 +83,7 @@ export interface CreateAgentWebAppInput {
   scope: AgentWebAppScope;
   features: AgentWebAppFeatures;
   appearance: AgentWebAppAppearance;
+  identity?: AgentWebAppIdentityConfig;
 }
 
 /** Editable fields accepted when updating an Agent Web App. Nested objects use merge semantics. */
@@ -64,6 +93,7 @@ export interface UpdateAgentWebAppInput {
   scope?: Partial<AgentWebAppScope>;
   features?: Partial<AgentWebAppFeatures>;
   appearance?: Partial<AgentWebAppAppearance>;
+  identity?: AgentWebAppIdentityConfig;
 }
 
 /** Internal persistence patch. Nested objects are complete replacements when provided. */
@@ -73,6 +103,7 @@ export interface AgentWebAppStorePatch {
   scope?: AgentWebAppScope;
   features?: AgentWebAppFeatures;
   appearance?: AgentWebAppAppearance;
+  identity?: AgentWebAppIdentityConfig;
   status?: AgentWebAppStatus;
 }
 

package/src/AgentWebAppStreamProjection.ts

@@ -0,0 +1,104 @@
+import { MessageChunkTypes, type MessageChunk } from "./MessageProtocol";
+import {
+  parseAgentWebAppGenUIBlock,
+  type AgentWebAppInterrupt,
+  type AgentWebAppStreamEvent,
+} from "./AgentWebAppRuntimeProtocol";
+
+/** Per-consumer projection metadata; it does not control Agent execution. */
+export interface AgentWebAppStreamProjectionContext {
+  readonly startedToolIds: Set<string>;
+  readonly allowInterrupts: boolean;
+  readonly allowGenUI: boolean;
+}
+
+/** Create projection metadata shared by all chunks in one public stream. */
+export function createAgentWebAppStreamProjectionContext(options: { allowInterrupts?: boolean; allowGenUI?: boolean } = {}): AgentWebAppStreamProjectionContext {
+  return { startedToolIds: new Set<string>(), allowInterrupts: options.allowInterrupts ?? true, allowGenUI: options.allowGenUI ?? false };
+}
+
+/** Purely project one internal Agent chunk onto zero or more stable public events. */
+export function projectAgentWebAppChunk(
+  chunk: MessageChunk,
+  context?: AgentWebAppStreamProjectionContext,
+): AgentWebAppStreamEvent[] {
+  if (chunk.type === MessageChunkTypes.AI) {
+    const events: AgentWebAppStreamEvent[] = [];
+    const startedToolIds = context?.startedToolIds ?? new Set<string>();
+    if (typeof chunk.data.content === "string" && chunk.data.content) events.push({ type: "message.delta", text: chunk.data.content });
+    if (context?.allowGenUI && Array.isArray(chunk.data.content)) {
+      for (const value of chunk.data.content) {
+        const block = parseAgentWebAppGenUIBlock(value);
+        if (block) events.push({ type: "genui.render", block });
+      }
+    }
+    for (const call of chunk.data.tool_call_chunks ?? []) {
+      if (call.id && call.name && !startedToolIds.has(call.id)) {
+        startedToolIds.add(call.id);
+        events.push({ type: "tool.started", id: call.id, name: call.name });
+      }
+    }
+    for (const call of chunk.data.tool_calls ?? []) {
+      if (!startedToolIds.has(call.id)) {
+        startedToolIds.add(call.id);
+        events.push({ type: "tool.started", id: call.id, name: call.name });
+      }
+    }
+    return events;
+  }
+  if (chunk.type === MessageChunkTypes.TOOL && chunk.data.tool_call_id) {
+    return [{ type: "tool.completed", id: chunk.data.tool_call_id }];
+  }
+  if (chunk.type === MessageChunkTypes.INTERRUPT) {
+    if (context && !context.allowInterrupts) return [{ type: "stream.completed" }];
+    const interrupt = publicInterrupt(chunk);
+    return interrupt
+      ? [{ type: "interrupt.created", interrupt }, { type: "stream.completed" }]
+      : [{ type: "stream.completed" }];
+  }
+  if (chunk.type === MessageChunkTypes.MESSAGE_COMPLETED) {
+    return [
+      { type: "message.completed", messageId: chunk.data.id },
+      { type: "stream.completed" },
+    ];
+  }
+  if (chunk.type === MessageChunkTypes.MESSAGE_FAILED) {
+    return [
+      { type: "error", error: { code: "STREAM_FAILED", message: "Stream failed", retryable: true } },
+      { type: "stream.completed" },
+    ];
+  }
+  return [];
+}
+
+function publicInterrupt(chunk: MessageChunk): AgentWebAppInterrupt | undefined {
+  const value = parseInterruptContent(chunk.data.content);
+  if (!value) return undefined;
+  const topLevelId = (chunk as unknown as { id?: unknown }).id;
+  const id = typeof topLevelId === "string" ? topLevelId : chunk.data.id;
+  if (!id) return undefined;
+  return {
+    id,
+    type: typeof value.type === "string" ? value.type : "input",
+    prompt: typeof value.prompt === "string"
+      ? value.prompt
+      : typeof value.message === "string" ? value.message : "Input required",
+    ...(isRecord(value.data) ? { data: value.data } : {}),
+  };
+}
+
+function parseInterruptContent(content: unknown): Record<string, unknown> | undefined {
+  if (!content) return {};
+  if (isRecord(content)) return content;
+  if (typeof content !== "string") return undefined;
+  try {
+    const parsed: unknown = JSON.parse(content);
+    return isRecord(parsed) ? parsed : { prompt: content };
+  } catch {
+    return { prompt: content };
+  }
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/src/index.ts

@@ -48,6 +48,7 @@ export * from "./A2AApiKeyStoreProtocol";
 export * from "./ConversationStoreProtocol";
 export * from "./AgentWebAppStoreProtocol";
 export * from "./AgentWebAppRuntimeProtocol";
+export * from "./AgentWebAppStreamProjection";
 export * from "./CapabilityBundleStoreProtocol";
 export * from "./CapabilityRuntimeProtocol";
 export * from "./ProjectRoomProtocol";