@ai2070/l0/dist/adapters/vercel-ai.js

L0: The Missing Reliability Substrate for AI

async function* wrapVercelAIStream(streamResult, options = {}) {
  const { includeUsage = true, includeToolCalls = true } = options;
  try {
    const fullStream = streamResult.fullStream;
    const reader = fullStream.getReader();
    while (true) {
      const { done, value } = await reader.read();
      if (done) {
        break;
      }
      if (!value) continue;
      const chunk = value;
      switch (chunk.type) {
        case "text-delta":
          yield {
            type: "token",
            value: chunk.text,
            timestamp: Date.now()
          };
          break;
        case "tool-call":
          if (includeToolCalls) {
            yield {
              type: "message",
              value: JSON.stringify({
                type: "tool_call",
                id: chunk.toolCallId,
                name: chunk.toolName,
                arguments: chunk.input
              }),
              role: "assistant",
              timestamp: Date.now()
            };
          }
          break;
        case "tool-input-start":
          break;
        case "tool-input-delta":
          break;
        case "tool-result":
          if (includeToolCalls) {
            yield {
              type: "message",
              value: JSON.stringify({
                type: "tool_result",
                id: chunk.toolCallId,
                name: chunk.toolName,
                result: chunk.output
              }),
              role: "tool",
              timestamp: Date.now()
            };
          }
          break;
        case "finish": {
          let usage;
          if (includeUsage) {
            try {
              usage = await streamResult.usage;
            } catch {
            }
          }
          yield {
            type: "complete",
            timestamp: Date.now(),
            ...includeUsage && usage ? { usage } : {},
            ...chunk.finishReason ? { finishReason: chunk.finishReason } : {}
          };
          break;
        }
        case "error":
          yield {
            type: "error",
            error: chunk.error instanceof Error ? chunk.error : new Error(String(chunk.error)),
            timestamp: Date.now()
          };
          break;
      }
    }
  } catch (error) {
    yield {
      type: "error",
      error: error instanceof Error ? error : new Error(String(error)),
      timestamp: Date.now()
    };
  }
}
function isVercelAIStream(obj) {
  if (!obj || typeof obj !== "object") {
    return false;
  }
  const stream = obj;
  return "textStream" in stream && "fullStream" in stream && "text" in stream && "toolCalls" in stream && "usage" in stream && "finishReason" in stream;
}
const vercelAIAdapter = {
  name: "vercel-ai",
  detect: isVercelAIStream,
  wrap: wrapVercelAIStream
};
import { registerAdapter } from "./registry";
try {
  registerAdapter(vercelAIAdapter, { silent: true });
} catch {
}
export {
  isVercelAIStream,
  vercelAIAdapter,
  wrapVercelAIStream
};
//# sourceMappingURL=vercel-ai.js.map