@ai2070/l0
Version:
L0: The Missing Reliability Substrate for AI
264 lines • 9.47 kB
JavaScript
export async function* wrapMastraStream(streamResult, options = {}) {
const { includeUsage = true, includeToolCalls = true, includeReasoning = false, } = options;
try {
const textStream = streamResult.textStream;
const reader = textStream.getReader();
while (true) {
const { done, value } = await reader.read();
if (done) {
break;
}
if (value) {
yield {
type: "token",
value,
timestamp: Date.now(),
};
}
}
if (includeReasoning) {
try {
const reasoningText = await streamResult.reasoningText;
if (reasoningText) {
yield {
type: "message",
value: JSON.stringify({
type: "reasoning",
reasoning: reasoningText,
}),
role: "assistant",
timestamp: Date.now(),
};
}
}
catch {
}
}
if (includeToolCalls) {
try {
const toolCalls = await streamResult.toolCalls;
if (toolCalls && toolCalls.length > 0) {
yield {
type: "message",
value: JSON.stringify({
type: "tool_calls",
tool_calls: toolCalls.map((tc) => ({
id: tc.payload?.toolCallId ?? tc.toolCallId,
name: tc.payload?.toolName ?? tc.toolName,
arguments: JSON.stringify(tc.payload?.args ?? tc.args),
})),
}),
role: "assistant",
timestamp: Date.now(),
};
}
}
catch {
}
try {
const toolResults = await streamResult.toolResults;
if (toolResults && toolResults.length > 0) {
yield {
type: "message",
value: JSON.stringify({
type: "tool_results",
tool_results: toolResults.map((tr) => ({
id: tr.payload?.toolCallId ?? tr.toolCallId,
name: tr.payload?.toolName ?? tr.toolName,
result: tr.payload?.result ?? tr.result,
})),
}),
role: "assistant",
timestamp: Date.now(),
};
}
}
catch {
}
}
let usage;
let finishReason;
if (includeUsage) {
try {
usage = await streamResult.usage;
}
catch {
}
}
try {
finishReason = await streamResult.finishReason;
}
catch {
}
yield {
type: "complete",
timestamp: Date.now(),
...(includeUsage && usage ? { usage } : {}),
...(finishReason ? { finishReason } : {}),
};
}
catch (error) {
yield {
type: "error",
error: error instanceof Error ? error : new Error(String(error)),
timestamp: Date.now(),
};
}
}
export function mastraStream(agent, messages, streamOptions, adapterOptions) {
return async () => {
const streamResult = await agent.stream(messages, streamOptions);
return wrapMastraStream(streamResult, adapterOptions);
};
}
export function mastraText(agent, prompt, options) {
const { includeUsage, includeToolCalls, includeReasoning, ...streamOptions } = options || {};
return mastraStream(agent, prompt, streamOptions, {
includeUsage,
includeToolCalls,
includeReasoning,
});
}
export function mastraStructured(agent, prompt, schema, options) {
const { includeUsage, includeToolCalls, includeReasoning, ...streamOptions } = options || {};
return mastraStream(agent, prompt, {
...streamOptions,
structuredOutput: { schema },
}, { includeUsage, includeToolCalls, includeReasoning });
}
export async function* wrapMastraFullStream(streamResult, options = {}) {
const { includeUsage = true, includeToolCalls = true, includeReasoning = false, } = 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.payload?.text ?? chunk.textDelta,
timestamp: Date.now(),
};
break;
case "reasoning":
if (includeReasoning) {
yield {
type: "message",
value: JSON.stringify({
type: "reasoning",
reasoning: chunk.payload?.text ?? chunk.textDelta,
}),
role: "assistant",
timestamp: Date.now(),
};
}
break;
case "tool-call":
if (includeToolCalls) {
const payload = chunk.payload ?? chunk;
yield {
type: "message",
value: JSON.stringify({
type: "tool_call",
tool_call: {
id: payload.toolCallId,
name: payload.toolName,
arguments: JSON.stringify(payload.args),
},
}),
role: "assistant",
timestamp: Date.now(),
};
}
break;
case "tool-result":
if (includeToolCalls) {
const payload = chunk.payload ?? chunk;
yield {
type: "message",
value: JSON.stringify({
type: "tool_result",
tool_result: {
id: payload.toolCallId,
name: payload.toolName,
result: payload.result,
},
}),
role: "assistant",
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(),
};
}
}
export function isMastraStream(obj) {
if (!obj || typeof obj !== "object") {
return false;
}
const stream = obj;
return ("textStream" in stream &&
"text" in stream &&
"usage" in stream &&
"finishReason" in stream &&
"runId" in stream &&
"messageList" in stream);
}
export async function extractMastraText(streamResult) {
return streamResult.text;
}
export async function extractMastraObject(streamResult) {
return streamResult.object;
}
export const mastraAdapter = {
name: "mastra",
detect: isMastraStream,
wrap: wrapMastraStream,
};
import { registerAdapter } from "./registry";
try {
registerAdapter(mastraAdapter, { silent: true });
}
catch {
}
//# sourceMappingURL=mastra.js.map