@anvia/client 1.0.0-rc.6 → 1.0.0

package/README.md

@@ -38,6 +38,10 @@ subpath; importing Client does not load the Agent runtime or its infrastructure
 - `parseUIMessage` and `parseUIMessages` validate externally loaded UI state.
 
 Tool-call start, delta, and end events are automatic when the provider exposes streamed arguments.
+`UIToolMessagePart` states are exact: `input-streaming` carries raw partial text,
+`input-available` carries parsed JSON input, and terminal `output-available` or `error` parts retain
+that input with their result. `uiMessagesToMessages()` rejects partial calls instead of replaying
+incomplete JSON or inventing empty arguments.
 Errors are masked by default. Use `mapError` only at the server adapter boundary when an application
 intentionally exposes a safe error shape. Non-JSON outputs require an explicit `mapOutput`; returning
 `undefined` intentionally omits the output, while returning `null` exposes JSON `null`.

package/dist/index.d.ts

@@ -72,6 +72,32 @@ type UIDataPart<Data extends ClientDataMap> = {
         data: Data[Name];
     };
 }[keyof Data & string];
+type UIToolMessagePartBase = {
+    id: string;
+    type: "tool";
+    toolName: string;
+    toolCallId: string;
+    callId?: string;
+    internalCallId?: string;
+    turn?: number;
+    signature?: string;
+};
+type UIToolMessagePart = (UIToolMessagePartBase & {
+    state: "input-streaming";
+    input: string;
+}) | (UIToolMessagePartBase & {
+    state: "input-available";
+    input: JsonValue;
+}) | (UIToolMessagePartBase & {
+    state: "output-available";
+    input: JsonValue;
+    output: JsonValue;
+    resultContent?: readonly ToolResultContentPart[];
+}) | (UIToolMessagePartBase & {
+    state: "error";
+    input: JsonValue;
+    error: UIError;
+});
 type UIMessagePart<Data extends ClientDataMap = ClientDataMap> = {
     id: string;
     type: "text";
@@ -83,21 +109,7 @@ type UIMessagePart<Data extends ClientDataMap = ClientDataMap> = {
     text: string;
     reasoningId?: string;
     content?: readonly ReasoningDetail[];
-} | {
-    id: string;
-    type: "tool";
-    toolName: string;
-    toolCallId: string;
-    callId?: string;
-    internalCallId?: string;
-    turn?: number;
-    state: "input-streaming" | "input-available" | "output-available" | "error";
-    input?: JsonValue;
-    output?: JsonValue;
-    resultContent?: readonly ToolResultContentPart[];
-    signature?: string;
-    error?: UIError;
-} | {
+} | UIToolMessagePart | {
     id: string;
     type: "source";
     source: CompletionSource;
@@ -110,9 +122,6 @@ type UIMessagePart<Data extends ClientDataMap = ClientDataMap> = {
     type: "error";
     error: UIError;
 };
-type UIToolMessagePart = Extract<UIMessagePart, {
-    type: "tool";
-}>;
 type ClientStreamCursor = {
     streamId: string;
     after: number;
@@ -243,7 +252,7 @@ type ClientStandardStreamEvent<Metadata extends JsonObject, Data extends ClientD
     callId?: string;
     internalCallId?: string;
     toolName: string;
-    input?: JsonValue;
+    input: JsonValue;
     result: {
         status: "success";
         output: JsonValue;

package/dist/index.js

@@ -59,11 +59,12 @@ function uiMessagesToMessages(messages) {
           if (part.content !== void 0) reasoning = { ...reasoning, details: part.content };
           content2.push(reasoning);
         } else if (part.type === "tool") {
+          assertReplayableToolPart(part);
           let toolCall = {
             type: "tool-call",
             toolCallId: part.toolCallId,
             toolName: part.toolName,
-            input: part.input ?? {}
+            input: part.input
           };
           if (part.callId !== void 0) toolCall = { ...toolCall, callId: part.callId };
           if (part.signature !== void 0) toolCall = { ...toolCall, signature: part.signature };
@@ -90,9 +91,12 @@ function uiMessagesToMessages(messages) {
       continue;
     }
     assertOnlyParts(message, ["tool", "data", "error"]);
-    const content = message.parts.flatMap(
-      (part) => part.type === "tool" && (part.state === "output-available" || part.state === "error") ? [toolResultFromPart(part)] : []
-    );
+    const content = [];
+    for (const part of message.parts) {
+      if (part.type !== "tool") continue;
+      assertToolResultPart(part);
+      content.push(toolResultFromPart(part));
+    }
     result.push({ role: "tool", content, ...metadataField(message.metadata) });
   }
   return result;
@@ -147,7 +151,13 @@ function messagesToUIMessages(messages) {
     for (const content of message.content) {
       if (content.type !== "tool-result") continue;
       const location = (content.callId === void 0 ? void 0 : byCallId.get(content.callId)) ?? byToolCallId.get(content.toolCallId);
-      const part = toolResultToUIMessagePart(content, toolNameAt(result, location));
+      const ownerPart = toolPartAt(result, location);
+      if (ownerPart === void 0 || ownerPart.state === "input-streaming") {
+        throw new TypeError(
+          `Tool result "${content.toolCallId}" requires a matching completed tool call.`
+        );
+      }
+      const part = toolResultToUIMessagePart(content, ownerPart.toolName, ownerPart.input);
       if (message.metadata === void 0 && location !== void 0) {
         const owner = result[location.messageIndex];
         const existing = owner?.parts[location.partIndex];
@@ -233,12 +243,12 @@ function toolResultFromPart(part) {
 }
 function toolOutputFromPart(part) {
   if (part.state === "error") {
-    return { type: "error-text", value: part.error?.message ?? "Tool execution failed." };
+    return { type: "error-text", value: part.error.message };
   }
   if (part.resultContent !== void 0) {
     return { type: "content", value: part.resultContent };
   }
-  const output = part.output ?? null;
+  const output = part.output;
   return typeof output === "string" ? { type: "text", value: output } : { type: "json", value: output };
 }
 function attachmentToUserContent(attachment) {
@@ -293,13 +303,14 @@ function contentToAttachment(content) {
   else attachment.text = content.data.text;
   return attachment;
 }
-function toolResultToUIMessagePart(content, fallbackToolName) {
+function toolResultToUIMessagePart(content, fallbackToolName, input) {
   const output = content.output;
   const common = {
     id: toolPartId(content.toolCallId),
     type: "tool",
-    toolName: content.toolName || fallbackToolName || "tool",
-    toolCallId: content.toolCallId
+    toolName: content.toolName || fallbackToolName,
+    toolCallId: content.toolCallId,
+    input
   };
   if (content.callId !== void 0) Object.assign(common, { callId: content.callId });
   if (output.type === "error-text" || output.type === "error-json") {
@@ -334,10 +345,28 @@ function toolResultOutput(output) {
     (part) => part.type === "text" ? { ...part } : { ...part, data: { ...part.data } }
   );
 }
-function toolNameAt(messages, location) {
+function toolPartAt(messages, location) {
   if (location === void 0) return void 0;
   const part = messages[location.messageIndex]?.parts[location.partIndex];
-  return part?.type === "tool" ? part.toolName : void 0;
+  return part?.type === "tool" ? part : void 0;
+}
+function assertReplayableToolPart(part) {
+  if (part.state === "input-streaming") {
+    throw new TypeError(
+      `Tool call "${part.toolCallId}" is still streaming and cannot be converted to a model message.`
+    );
+  }
+  if (!isJsonValue(part.input)) {
+    throw new TypeError(`Tool call "${part.toolCallId}" input must be a strict JSON value.`);
+  }
+}
+function assertToolResultPart(part) {
+  assertReplayableToolPart(part);
+  if (part.state === "input-available") {
+    throw new TypeError(
+      `Tool message part "${part.toolCallId}" requires an output or execution error.`
+    );
+  }
 }
 function textFromParts(parts) {
   return parts.flatMap((part) => part.type === "text" ? [part.text] : []).join("");
@@ -612,6 +641,7 @@ function parseClientStreamEvent(value, options = {}) {
       ]);
       requireStrings(event, ["messageId", "partId", "toolCallId", "toolName"], value);
       requireOptionalStrings(event, ["callId", "internalCallId"], value);
+      if (!isJsonValue2(event.input)) invalid("tool_result.input", value);
       if (!isRecord(event.result)) invalid("tool_result.result", value);
       if (event.result.status === "success") {
         if (!hasOnlyKeys(event.result, ["status", "output", "content"]) || !isJsonValue2(event.result.output) || event.result.content !== void 0 && (!Array.isArray(event.result.content) || !event.result.content.every(isToolResultContent))) {
@@ -700,6 +730,10 @@ function parseClientStreamEvent(value, options = {}) {
         "originalMessageCount",
         "compactedMessageCount",
         "retainedMessageCount",
+        "originalTokenCount",
+        "compactedTokenCount",
+        "retainedTokenCount",
+        "resultTokenCount",
         "attempts",
         "usage"
       ]);
@@ -733,6 +767,10 @@ function parseClientStreamEvent(value, options = {}) {
             "originalMessageCount",
             "compactedMessageCount",
             "retainedMessageCount",
+            "originalTokenCount",
+            "compactedTokenCount",
+            "retainedTokenCount",
+            "resultTokenCount",
             "attempts",
             "usage"
           ],
@@ -864,6 +902,10 @@ function validateMemoryCompactionForGuard(value) {
         "originalMessageCount",
         "compactedMessageCount",
         "retainedMessageCount",
+        "originalTokenCount",
+        "compactedTokenCount",
+        "retainedTokenCount",
+        "resultTokenCount",
         "attempts",
         "usage"
       ],
@@ -930,7 +972,7 @@ function isUIMessagePart(value) {
   if (value.type === "error") {
     return hasOnlyKeys(value, ["id", "type", "error"]) && isClientStreamError(value.error);
   }
-  return value.type === "tool" && hasOnlyKeys(value, [
+  if (value.type !== "tool" || !hasOnlyKeys(value, [
     "id",
     "type",
     "toolName",
@@ -944,9 +986,19 @@ function isUIMessagePart(value) {
     "resultContent",
     "signature",
     "error"
-  ]) && typeof value.toolName === "string" && typeof value.toolCallId === "string" && (value.callId === void 0 || typeof value.callId === "string") && (value.internalCallId === void 0 || typeof value.internalCallId === "string") && (value.turn === void 0 || isPositiveEventId(value.turn)) && (value.signature === void 0 || typeof value.signature === "string") && (value.input === void 0 || isJsonValue2(value.input)) && (value.output === void 0 || isJsonValue2(value.output)) && (value.resultContent === void 0 || Array.isArray(value.resultContent) && value.resultContent.every(isToolResultContent)) && (value.error === void 0 || isClientStreamError(value.error)) && ["input-streaming", "input-available", "output-available", "error"].includes(
-    value.state
-  );
+  ]) || typeof value.toolName !== "string" || typeof value.toolCallId !== "string" || value.callId !== void 0 && typeof value.callId !== "string" || value.internalCallId !== void 0 && typeof value.internalCallId !== "string" || value.turn !== void 0 && !isPositiveEventId(value.turn) || value.signature !== void 0 && typeof value.signature !== "string") {
+    return false;
+  }
+  if (value.state === "input-streaming") {
+    return typeof value.input === "string" && value.output === void 0 && value.resultContent === void 0 && value.error === void 0;
+  }
+  if (value.state === "input-available") {
+    return isJsonValue2(value.input) && value.output === void 0 && value.resultContent === void 0 && value.error === void 0;
+  }
+  if (value.state === "output-available") {
+    return isJsonValue2(value.input) && isJsonValue2(value.output) && (value.resultContent === void 0 || Array.isArray(value.resultContent) && value.resultContent.every(isToolResultContent)) && value.error === void 0;
+  }
+  return value.state === "error" && isJsonValue2(value.input) && value.output === void 0 && value.resultContent === void 0 && isClientStreamError(value.error);
 }
 function isReasoningContent(value) {
   if (!isRecord(value) || typeof value.type !== "string") return false;
@@ -1037,7 +1089,15 @@ function validateUsageAndContext(event, original) {
   }
 }
 function validateMemoryCompactionInfo(value, original) {
-  for (const field of ["originalMessageCount", "compactedMessageCount", "retainedMessageCount"]) {
+  for (const field of [
+    "originalMessageCount",
+    "compactedMessageCount",
+    "retainedMessageCount",
+    "originalTokenCount",
+    "compactedTokenCount",
+    "retainedTokenCount",
+    "resultTokenCount"
+  ]) {
     if (!isEventId(value[field])) invalid(`memory_compaction.${field}`, original);
   }
   if (!isPositiveEventId(value.attempts)) invalid("memory_compaction.attempts", original);
@@ -1261,6 +1321,10 @@ async function* translateAgentEvent(runtime, event, scope) {
         originalMessageCount: event.originalMessageCount,
         compactedMessageCount: event.compactedMessageCount,
         retainedMessageCount: event.retainedMessageCount,
+        originalTokenCount: event.originalTokenCount,
+        compactedTokenCount: event.compactedTokenCount,
+        retainedTokenCount: event.retainedTokenCount,
+        resultTokenCount: event.resultTokenCount,
         attempts: event.attempts,
         usage: event.usage
       });
@@ -1372,18 +1436,20 @@ async function* translateAgentEvent(runtime, event, scope) {
         decision: event.decision
       });
       return;
-    case "final": {
-      const result = event.result;
-      if (result.status === "suspended" && scope === void 0) {
+    case "response":
+    case "interaction":
+    case "blocked": {
+      const result = event;
+      if (result.type === "interaction" && scope === void 0) {
         yield scopedEvent(runtime.runId, turn, scope, {
           type: "interaction",
           interaction: result.interaction
         });
       }
-      const output = result.status === "completed" ? clientOutput(result.output, runtime.options.mapOutput) : void 0;
+      const output = result.type === "response" ? clientOutput(result.output, runtime.options.mapOutput) : void 0;
       const runEnd = {
         type: "run_end",
-        status: result.status,
+        status: agentOutcomeStatus(result.type),
         text: result.text,
         usage: result.usage
       };
@@ -1759,25 +1825,43 @@ function contentToUIMessageParts(content, state) {
     }
     if (contentPart.type === "tool-call") {
       const tool = getToolState(state, contentPart.toolCallId, contentPart.toolName);
-      const part = {
+      const partBase = {
         id: tool.partId,
         type: "tool",
         toolName: contentPart.toolName,
-        toolCallId: contentPart.toolCallId,
-        state: tool.result?.status === "error" ? "error" : tool.result ? "output-available" : "input-available",
-        input: contentPart.input
+        toolCallId: contentPart.toolCallId
       };
-      if (contentPart.callId !== void 0) part.callId = contentPart.callId;
-      if (tool.internalCallId !== void 0) part.internalCallId = tool.internalCallId;
-      if (state.turn !== void 0) part.turn = state.turn;
-      if (contentPart.signature !== void 0) part.signature = contentPart.signature;
+      if (contentPart.callId !== void 0) Object.assign(partBase, { callId: contentPart.callId });
+      if (tool.internalCallId !== void 0) {
+        Object.assign(partBase, { internalCallId: tool.internalCallId });
+      }
+      if (state.turn !== void 0) Object.assign(partBase, { turn: state.turn });
+      if (contentPart.signature !== void 0) {
+        Object.assign(partBase, { signature: contentPart.signature });
+      }
       if (tool.result?.status === "success") {
-        part.output = tool.result.output;
+        const part = {
+          ...partBase,
+          state: "output-available",
+          input: contentPart.input,
+          output: tool.result.output
+        };
         if (tool.result.content !== void 0) part.resultContent = tool.result.content;
-      } else if (tool.result?.status === "error") {
-        part.error = tool.result.error;
+        return part;
       }
-      return part;
+      if (tool.result?.status === "error") {
+        return {
+          ...partBase,
+          state: "error",
+          input: contentPart.input,
+          error: tool.result.error
+        };
+      }
+      return {
+        ...partBase,
+        state: "input-available",
+        input: contentPart.input
+      };
     }
     const attachment = contentAttachment(contentPart);
     return {
@@ -1939,7 +2023,12 @@ function scopeKey(scope) {
   ].join(":");
 }
 function isRootTerminalAgentEvent(event) {
-  return event.type === "final" || event.type === "error";
+  return event.type === "response" || event.type === "interaction" || event.type === "blocked" || event.type === "error";
+}
+function agentOutcomeStatus(type) {
+  if (type === "response") return "completed";
+  if (type === "interaction") return "suspended";
+  return "blocked";
 }
 function propagateCancellation(source, transform) {
   return {
@@ -2193,21 +2282,22 @@ function applyClientStreamEvent(messages, event) {
     }
     case "tool_call_delta":
       return updatePart(messages, event.messageId, event.partId, (current) => {
-        const part = current?.type === "tool" ? { ...current } : {
+        const part = current?.type === "tool" ? toolPartBase(current) : {
           id: event.partId,
           type: "tool",
           toolName: event.toolName ?? "",
-          toolCallId: event.toolCallId,
-          state: "input-streaming"
+          toolCallId: event.toolCallId
         };
-        const previous = typeof part.input === "string" ? part.input : "";
-        part.input = event.mode === "replace" ? event.delta : `${previous}${event.delta}`;
-        part.state = "input-streaming";
+        const previous = current?.type === "tool" && typeof current.input === "string" ? current.input : "";
         if (event.toolName !== void 0) part.toolName = event.toolName;
         if (event.callId !== void 0) part.callId = event.callId;
         if (event.signature !== void 0) part.signature = event.signature;
         if (event.turn !== void 0) part.turn = event.turn;
-        return part;
+        return {
+          ...part,
+          state: "input-streaming",
+          input: event.mode === "replace" ? event.delta : `${previous}${event.delta}`
+        };
       });
     case "tool_call_end": {
       const part = {
@@ -2225,26 +2315,31 @@ function applyClientStreamEvent(messages, event) {
     }
     case "tool_result":
       return updatePart(messages, event.messageId, event.partId, (current) => {
-        const part = current?.type === "tool" ? { ...current } : {
+        const part = current?.type === "tool" ? toolPartBase(current) : {
           id: event.partId,
           type: "tool",
           toolName: event.toolName,
-          toolCallId: event.toolCallId,
-          state: "input-available"
+          toolCallId: event.toolCallId
         };
         if (event.callId !== void 0) part.callId = event.callId;
         if (event.internalCallId !== void 0) part.internalCallId = event.internalCallId;
-        if (event.input !== void 0) part.input = event.input;
         if (event.turn !== void 0) part.turn = event.turn;
         if (event.result.status === "error") {
-          part.state = "error";
-          part.error = event.result.error;
-        } else {
-          part.state = "output-available";
-          part.output = event.result.output;
-          if (event.result.content !== void 0) part.resultContent = event.result.content;
+          return {
+            ...part,
+            state: "error",
+            input: event.input,
+            error: event.result.error
+          };
         }
-        return part;
+        const completed = {
+          ...part,
+          state: "output-available",
+          input: event.input,
+          output: event.result.output
+        };
+        if (event.result.content !== void 0) completed.resultContent = event.result.content;
+        return completed;
       });
     case "source":
       return upsertPart(messages, event.messageId, {
@@ -2314,6 +2409,21 @@ function applyClientStreamEvent(messages, event) {
       return messages;
   }
 }
+function toolPartBase(part) {
+  const base = {
+    id: part.id,
+    type: part.type,
+    toolName: part.toolName,
+    toolCallId: part.toolCallId
+  };
+  if (part.callId !== void 0) Object.assign(base, { callId: part.callId });
+  if (part.internalCallId !== void 0) {
+    Object.assign(base, { internalCallId: part.internalCallId });
+  }
+  if (part.turn !== void 0) Object.assign(base, { turn: part.turn });
+  if (part.signature !== void 0) Object.assign(base, { signature: part.signature });
+  return base;
+}
 function reconcileFinalParts(current, final) {
   const clientOnly = current.filter(
     (part) => part.type === "source" || part.type === "data" || part.type === "error"