@mastra/server-adapters-test-suite 0.1.4-alpha.1 → 0.2.0-alpha.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/index.js CHANGED
@@ -1,7 +1,7 @@
1
1
  import { ErrorCategory, ErrorDomain, MastraError } from "@mastra/core/error";
2
2
  import { registerApiRoute } from "@mastra/core/server";
3
3
  import { handleError } from "@mastra/server/handlers/error";
4
- import { HTTPException, SERVER_ROUTES, WorkflowRegistry, createRoute } from "@mastra/server/server-adapter";
4
+ import { HTTPException, SERVER_ROUTES, WorkflowRegistry, createRoute, serializeStreamChunk } from "@mastra/server/server-adapter";
5
5
  import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
6
6
  import * as zod from "zod";
7
7
  import { z } from "zod";
@@ -25,14 +25,14 @@ import { CompositeVoice } from "@mastra/core/voice";
25
25
  import { createStep, createWorkflow } from "@mastra/core/workflows";
26
26
  import { LocalFilesystem, Workspace } from "@mastra/core/workspace";
27
27
  import { MCPClient, MCPServer, defineEvent } from "@mastra/mcp";
28
- import { createDurableAgent, createEventedAgent } from "@mastra/core/agent/durable";
28
+ import { AGENT_STREAM_TOPIC, createDurableAgent, createDurableAgentStream, createEventedAgent } from "@mastra/core/agent/durable";
29
29
  import { Mastra as Mastra$1 } from "@mastra/core/mastra";
30
30
  import http from "http";
31
31
  import { MCPServerBase } from "@mastra/core/mcp";
32
32
  import { RequestContext } from "@mastra/core/request-context";
33
33
  import { standardSchemaToJSONSchema } from "@mastra/core/schema";
34
34
  import { z as z$2 } from "zod/v4";
35
- //#region src/route-test-utils.ts
35
+ // src/route-test-utils.ts
36
36
  /**
37
37
  * Normalizes a route path to ensure consistent formatting.
38
38
  * - Removes leading/trailing whitespace
@@ -241,7 +241,7 @@ function generateValidDataFromSchema(schema, fieldName) {
241
241
  if (typeName === "ZodNull") return null;
242
242
  if (typeName === "ZodUndefined") return void 0;
243
243
  if (typeName === "ZodDate") return /* @__PURE__ */ new Date();
244
- if (typeName === "ZodBigInt") return BigInt(0);
244
+ if (typeName === "ZodBigInt") return 0n;
245
245
  if (typeName === "ZodLiteral") {
246
246
  if ("_zod" in schema) return def.values?.[0];
247
247
  else return def.value;
@@ -420,8 +420,7 @@ function validateRouteMetadata(route, expected) {
420
420
  if (hasOpenAPI !== expected.hasOpenAPI) throw new Error(`Expected openapi to be ${expected.hasOpenAPI ? "defined" : "undefined"} but got ${hasOpenAPI ? "defined" : "undefined"}`);
421
421
  }
422
422
  }
423
- //#endregion
424
- //#region src/route-test-suite.ts
423
+ // src/route-test-suite.ts
425
424
  /**
426
425
  * Creates a standardized test suite for server adapter routes
427
426
  * Similar to stores/_test-utils pattern
@@ -498,8 +497,7 @@ function createRouteTestSuite(config) {
498
497
  });
499
498
  });
500
499
  }
501
- //#endregion
502
- //#region src/test-helpers.ts
500
+ // src/test-helpers.ts
503
501
  if (process.env.VITEST) {
504
502
  vi.mock("@mastra/core/vector");
505
503
  vi.mock("zod", async (importOriginal) => {
@@ -1774,8 +1772,7 @@ async function consumeSSEStream(stream) {
1774
1772
  }
1775
1773
  return chunks;
1776
1774
  }
1777
- //#endregion
1778
- //#region src/route-adapter-test-suite.ts
1775
+ // src/route-adapter-test-suite.ts
1779
1776
  /**
1780
1777
  * Creates a standardized integration test suite for server adapters (Express/Hono)
1781
1778
  *
@@ -3013,8 +3010,146 @@ function createRouteAdapterTestSuite(config) {
3013
3010
  });
3014
3011
  });
3015
3012
  }
3016
- //#endregion
3017
- //#region src/durable-disconnect-test-suite.ts
3013
+ // src/structured-wake-test-suite.ts
3014
+ const structuredOutput = {
3015
+ schema: {
3016
+ type: "object",
3017
+ properties: { summary: { type: "string" } },
3018
+ required: ["summary"]
3019
+ },
3020
+ jsonPromptInjection: true
3021
+ };
3022
+ function createStructuredWakeTestSuite(config) {
3023
+ describe.each([
3024
+ "plain",
3025
+ "durable",
3026
+ "evented"
3027
+ ])("HTTP structured idle wake: %s", (kind) => {
3028
+ it.each([{
3029
+ name: "invalid plain text",
3030
+ content: "This is plain text, not JSON.",
3031
+ valid: false
3032
+ }, {
3033
+ name: "valid JSON",
3034
+ content: "{\"summary\":\"hello\"}",
3035
+ valid: true
3036
+ }])("delivers $name result before the terminal boundary", async ({ content, valid }) => {
3037
+ const model = await config.setupModel();
3038
+ const storage = new InMemoryStore();
3039
+ const inner = new Agent({
3040
+ id: "structured-wake-agent",
3041
+ name: "Structured wake agent",
3042
+ instructions: "Respond to the message.",
3043
+ model: model.model,
3044
+ memory: new MockMemory({ storage }),
3045
+ errorProcessors: []
3046
+ });
3047
+ const agent = kind === "durable" ? createDurableAgent({ agent: inner }) : kind === "evented" ? createEventedAgent({ agent: inner }) : inner;
3048
+ const mastra = new Mastra$1({
3049
+ agents: { agent },
3050
+ storage,
3051
+ logger: false
3052
+ });
3053
+ let server;
3054
+ let reader;
3055
+ const abort = new AbortController();
3056
+ const timeout = setTimeout(() => abort.abort(), 15e3);
3057
+ try {
3058
+ model.addResponse(0, { content });
3059
+ model.addResponse(1, { content });
3060
+ server = await config.startServer(mastra);
3061
+ const base = `${server.baseUrl}/api/agents/agent`;
3062
+ const post = (path, body) => fetch(`${base}/${path}`, {
3063
+ method: "POST",
3064
+ headers: { "content-type": "application/json" },
3065
+ body: JSON.stringify(body),
3066
+ signal: abort.signal
3067
+ });
3068
+ const subscription = await post("threads/subscribe", {
3069
+ resourceId: "r",
3070
+ threadId: "t"
3071
+ });
3072
+ expect(subscription.status).toBe(200);
3073
+ reader = subscription.body.getReader();
3074
+ expect(agent.getActiveThreadRunId({
3075
+ resourceId: "r",
3076
+ threadId: "t"
3077
+ })).toBeUndefined();
3078
+ const send = await post("send-message", {
3079
+ resourceId: "r",
3080
+ threadId: "t",
3081
+ message: "hi",
3082
+ ifIdle: { streamOptions: { structuredOutput } }
3083
+ });
3084
+ expect(send.status).toBe(200);
3085
+ await send.json();
3086
+ const frames = [];
3087
+ const decoder = new TextDecoder();
3088
+ let pending = "";
3089
+ let terminal = false;
3090
+ while (!terminal) {
3091
+ const { done, value } = await reader.read();
3092
+ if (done) break;
3093
+ pending += decoder.decode(value, { stream: true });
3094
+ let end;
3095
+ while (!terminal && (end = pending.indexOf("\n\n")) >= 0) {
3096
+ const block = pending.slice(0, end);
3097
+ pending = pending.slice(end + 2);
3098
+ for (const line of block.split("\n")) {
3099
+ if (!line.startsWith("data: ")) continue;
3100
+ const data = line.slice(6);
3101
+ if (data === "[DONE]") {
3102
+ terminal = true;
3103
+ break;
3104
+ }
3105
+ const frame = JSON.parse(data);
3106
+ frames.push(frame);
3107
+ if ([
3108
+ "finish",
3109
+ "error",
3110
+ "abort"
3111
+ ].includes(frame.type)) {
3112
+ terminal = true;
3113
+ break;
3114
+ }
3115
+ }
3116
+ }
3117
+ }
3118
+ const control = await post("stream-until-idle", {
3119
+ messages: "hi",
3120
+ memory: {
3121
+ resource: "r",
3122
+ thread: "control"
3123
+ },
3124
+ structuredOutput
3125
+ });
3126
+ expect(control.status).toBe(200);
3127
+ const controlText = await control.text();
3128
+ if (valid) {
3129
+ expect(frames).toContainEqual(expect.objectContaining({
3130
+ type: "object-result",
3131
+ object: { summary: "hello" }
3132
+ }));
3133
+ expect(frames.at(-1)?.type).toBe("finish");
3134
+ expect(controlText).toContain("object-result");
3135
+ } else {
3136
+ expect(controlText).toContain("STRUCTURED_OUTPUT_SCHEMA_VALIDATION_FAILED");
3137
+ expect(JSON.stringify(frames)).toContain("STRUCTURED_OUTPUT_SCHEMA_VALIDATION_FAILED");
3138
+ expect(frames.at(-1)?.type).toBe("error");
3139
+ }
3140
+ expect(model.getRequestCount()).toBe(2);
3141
+ } finally {
3142
+ clearTimeout(timeout);
3143
+ abort.abort();
3144
+ await reader?.cancel().catch(() => {});
3145
+ await mastra.shutdown();
3146
+ await server?.close();
3147
+ await model.close();
3148
+ }
3149
+ }, 3e4);
3150
+ });
3151
+ }
3152
+ // src/durable-disconnect-test-suite.ts
3018
3153
  function deferred() {
3019
3154
  let resolve;
3020
3155
  return {
@@ -3024,6 +3159,30 @@ function deferred() {
3024
3159
  resolve
3025
3160
  };
3026
3161
  }
3162
+ async function collectPublicFrames(response, onFrame) {
3163
+ const frames = [];
3164
+ const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
3165
+ let buffer = "";
3166
+ try {
3167
+ while (true) {
3168
+ const { done, value } = await reader.read();
3169
+ if (done) return frames;
3170
+ buffer += value;
3171
+ const events = buffer.split(/\r?\n\r?\n/);
3172
+ buffer = events.pop();
3173
+ for (const event of events) for (const line of event.split(/\r?\n/)) {
3174
+ if (!line.startsWith("data: ")) continue;
3175
+ const data = line.slice(6);
3176
+ if (data === "[DONE]") continue;
3177
+ const frame = JSON.parse(data);
3178
+ frames.push(frame);
3179
+ onFrame?.(frame);
3180
+ }
3181
+ }
3182
+ } finally {
3183
+ reader.releaseLock();
3184
+ }
3185
+ }
3027
3186
  function createDurableDisconnectTestSuite(config) {
3028
3187
  describe.each([
3029
3188
  "plain",
@@ -3041,6 +3200,539 @@ function createDurableDisconnectTestSuite(config) {
3041
3200
  mastra = void 0;
3042
3201
  fixture = void 0;
3043
3202
  });
3203
+ it("forwards history and ordered run outcomes without closing the thread subscription (COR-1500)", async () => {
3204
+ fixture = await config.setupModel();
3205
+ fixture.addResponse(0, { content: "first answer" });
3206
+ fixture.addResponse(1, { content: "second answer" });
3207
+ const inner = new Agent({
3208
+ id: "subscription-agent",
3209
+ name: "Subscription agent",
3210
+ instructions: "Answer briefly.",
3211
+ model: fixture.model,
3212
+ memory: new MockMemory({ storage: new InMemoryStore() })
3213
+ });
3214
+ const agent = kind === "durable" ? createDurableAgent({ agent: inner }) : kind === "evented" ? createEventedAgent({ agent: inner }) : inner;
3215
+ mastra = new Mastra$1({
3216
+ agents: { agent },
3217
+ storage: new InMemoryStore()
3218
+ });
3219
+ server = await config.startServer(mastra, () => {});
3220
+ const controller = new AbortController();
3221
+ const coordinates = {
3222
+ resourceId: "subscription-user",
3223
+ threadId: `subscription-${kind}`
3224
+ };
3225
+ const response = await fetch(`${server.baseUrl}/api/agents/agent/threads/subscribe`, {
3226
+ method: "POST",
3227
+ headers: { "content-type": "application/json" },
3228
+ body: JSON.stringify({
3229
+ ...coordinates,
3230
+ withInitialHistory: true,
3231
+ withRunStatus: true
3232
+ }),
3233
+ signal: controller.signal
3234
+ });
3235
+ expect(response.status).toBe(200);
3236
+ const reader = response.body.getReader();
3237
+ const decoder = new TextDecoder();
3238
+ let buffered = "";
3239
+ async function nextChunk() {
3240
+ for (;;) {
3241
+ const boundary = buffered.indexOf("\n\n");
3242
+ if (boundary !== -1) {
3243
+ const frame = buffered.slice(0, boundary);
3244
+ buffered = buffered.slice(boundary + 2);
3245
+ const data = frame.split("\n").find((line) => line.startsWith("data: "));
3246
+ if (data) return JSON.parse(data.slice(6));
3247
+ } else {
3248
+ const next = await reader.read();
3249
+ expect(next.done).toBe(false);
3250
+ buffered += decoder.decode(next.value, { stream: true });
3251
+ }
3252
+ }
3253
+ }
3254
+ try {
3255
+ expect(await nextChunk()).toMatchObject({
3256
+ type: "thread-history",
3257
+ payload: { activeRunId: null }
3258
+ });
3259
+ for (const answer of ["first answer", "second answer"]) {
3260
+ const reading = (async () => {
3261
+ let text = "";
3262
+ for (;;) {
3263
+ const chunk = await nextChunk();
3264
+ if (chunk.type === "text-delta") text += chunk.payload.text;
3265
+ if (chunk.type === "thread-run-status") return {
3266
+ text,
3267
+ runId: chunk.runId,
3268
+ status: chunk.payload.status
3269
+ };
3270
+ }
3271
+ })();
3272
+ const output = await agent.stream("Hello", { memory: {
3273
+ thread: coordinates.threadId,
3274
+ resource: coordinates.resourceId
3275
+ } });
3276
+ for await (const _chunk of output.fullStream);
3277
+ expect(await reading).toEqual({
3278
+ text: answer,
3279
+ runId: output.runId,
3280
+ status: "success"
3281
+ });
3282
+ }
3283
+ } finally {
3284
+ controller.abort();
3285
+ await reader.cancel().catch(() => {});
3286
+ }
3287
+ }, 3e4);
3288
+ if (kind !== "plain") {
3289
+ it.each([
3290
+ "error",
3291
+ "abort",
3292
+ "abort-without-text",
3293
+ "aborted-finish"
3294
+ ])("replays %s as public terminal frames (COR-1498)", async (terminal) => {
3295
+ fixture = await config.setupModel();
3296
+ const agent = (kind === "durable" ? createDurableAgent : createEventedAgent)({
3297
+ agent: new Agent({
3298
+ id: "terminal-agent",
3299
+ name: "Terminal agent",
3300
+ instructions: "Unused",
3301
+ model: fixture.model
3302
+ }),
3303
+ cleanupTimeoutMs: 6e4
3304
+ });
3305
+ mastra = new Mastra$1({
3306
+ agents: { agent },
3307
+ storage: new InMemoryStore(),
3308
+ logger: false
3309
+ });
3310
+ server = await config.startServer(mastra, () => {});
3311
+ const runId = `observe-terminal-${kind}-${terminal}`;
3312
+ const topic = AGENT_STREAM_TOPIC(runId);
3313
+ await agent.pubsub.publish(topic, {
3314
+ runId,
3315
+ type: "iteration-complete",
3316
+ data: {}
3317
+ });
3318
+ await agent.pubsub.publish(topic, {
3319
+ runId,
3320
+ type: "suspended",
3321
+ data: { type: "suspension" }
3322
+ });
3323
+ await agent.pubsub.publish(topic, {
3324
+ runId,
3325
+ type: terminal === "aborted-finish" ? "finish" : terminal === "abort-without-text" ? "abort" : terminal,
3326
+ data: terminal === "error" ? { error: {
3327
+ id: "TEST_ERROR",
3328
+ name: "ProviderError",
3329
+ message: "Provider unavailable",
3330
+ stack: "producer-stack"
3331
+ } } : terminal === "abort" || terminal === "abort-without-text" ? {
3332
+ ...terminal === "abort" ? { text: "partial answer" } : {},
3333
+ steps: []
3334
+ } : {
3335
+ output: {
3336
+ text: "partial answer",
3337
+ steps: [],
3338
+ usage: {
3339
+ inputTokens: 1,
3340
+ outputTokens: 2,
3341
+ totalTokens: 3
3342
+ }
3343
+ },
3344
+ stepResult: { reason: "abort" }
3345
+ }
3346
+ });
3347
+ const reference = createDurableAgentStream({
3348
+ pubsub: agent.pubsub,
3349
+ runId,
3350
+ messageId: "reference",
3351
+ model: {
3352
+ version: "v3",
3353
+ modelId: void 0,
3354
+ provider: void 0
3355
+ }
3356
+ });
3357
+ const expected = [];
3358
+ try {
3359
+ for await (const chunk of reference.output.fullStream) {
3360
+ const serialized = serializeStreamChunk(chunk);
3361
+ if (!serialized.ok) throw serialized.error;
3362
+ expected.push(JSON.parse(serialized.json));
3363
+ }
3364
+ } finally {
3365
+ await reference.cleanup();
3366
+ }
3367
+ for (const offset of [
3368
+ 0,
3369
+ 1,
3370
+ 2
3371
+ ]) {
3372
+ const response = await fetch(`${server.baseUrl}/api/agents/agent/observe`, {
3373
+ method: "POST",
3374
+ headers: { "content-type": "application/json" },
3375
+ body: JSON.stringify({
3376
+ runId,
3377
+ offset
3378
+ })
3379
+ });
3380
+ expect(response.status).toBe(200);
3381
+ expect(await collectPublicFrames(response)).toEqual(expected);
3382
+ }
3383
+ expect(expected).toHaveLength(terminal === "error" ? 1 : 2);
3384
+ if (config.observeWithClient) expect(await config.observeWithClient(server.baseUrl, runId)).toEqual(expected);
3385
+ });
3386
+ it("preserves finish metadata after a model error chunk (COR-1498)", async () => {
3387
+ fixture = await config.setupModel();
3388
+ const agent = (kind === "durable" ? createDurableAgent : createEventedAgent)({ agent: new Agent({
3389
+ id: "error-agent",
3390
+ name: "Error agent",
3391
+ instructions: "Unused",
3392
+ model: fixture.model
3393
+ }) });
3394
+ mastra = new Mastra$1({
3395
+ agents: { agent },
3396
+ storage: new InMemoryStore(),
3397
+ logger: false
3398
+ });
3399
+ server = await config.startServer(mastra, () => {});
3400
+ const runId = `observe-model-error-${kind}`;
3401
+ const usage = {
3402
+ inputTokens: 1,
3403
+ outputTokens: 2,
3404
+ totalTokens: 3
3405
+ };
3406
+ const output = {
3407
+ text: "",
3408
+ steps: [],
3409
+ usage
3410
+ };
3411
+ const stepResult = {
3412
+ reason: "error",
3413
+ warnings: [],
3414
+ isContinued: false
3415
+ };
3416
+ await agent.pubsub.publish(AGENT_STREAM_TOPIC(runId), {
3417
+ runId,
3418
+ type: "chunk",
3419
+ data: {
3420
+ type: "error",
3421
+ runId,
3422
+ from: "AGENT",
3423
+ payload: { error: { message: "Provider unavailable" } }
3424
+ }
3425
+ });
3426
+ await agent.pubsub.publish(AGENT_STREAM_TOPIC(runId), {
3427
+ runId,
3428
+ type: "chunk",
3429
+ data: {
3430
+ type: "step-finish",
3431
+ runId,
3432
+ from: "AGENT",
3433
+ payload: {
3434
+ output,
3435
+ stepResult,
3436
+ metadata: {}
3437
+ }
3438
+ }
3439
+ });
3440
+ await agent.pubsub.publish(AGENT_STREAM_TOPIC(runId), {
3441
+ runId,
3442
+ type: "finish",
3443
+ data: {
3444
+ output,
3445
+ stepResult
3446
+ }
3447
+ });
3448
+ const reference = createDurableAgentStream({
3449
+ pubsub: agent.pubsub,
3450
+ runId,
3451
+ messageId: "reference",
3452
+ model: {
3453
+ version: "v3",
3454
+ modelId: void 0,
3455
+ provider: void 0
3456
+ }
3457
+ });
3458
+ const expected = [];
3459
+ try {
3460
+ for await (const chunk of reference.output.fullStream) {
3461
+ const serialized = serializeStreamChunk(chunk);
3462
+ if (!serialized.ok) throw serialized.error;
3463
+ expected.push(JSON.parse(serialized.json));
3464
+ }
3465
+ } finally {
3466
+ await reference.cleanup();
3467
+ }
3468
+ const frames = await collectPublicFrames(await fetch(`${server.baseUrl}/api/agents/agent/observe`, {
3469
+ method: "POST",
3470
+ headers: { "content-type": "application/json" },
3471
+ body: JSON.stringify({ runId })
3472
+ }));
3473
+ expect(frames.map((frame) => frame.type)).toEqual([
3474
+ "error",
3475
+ "step-finish",
3476
+ "finish"
3477
+ ]);
3478
+ expect(frames).toEqual(expected);
3479
+ expect(frames.at(-1)).toMatchObject({ payload: {
3480
+ output: { usage },
3481
+ stepResult: { reason: "error" }
3482
+ } });
3483
+ if (config.observeWithClient) expect(await config.observeWithClient(server.baseUrl, runId)).toEqual(expected);
3484
+ });
3485
+ it.each([false, true])("matches public finish usage when terminal raw is present: %s (COR-1498)", async (explicit) => {
3486
+ fixture = await config.setupModel();
3487
+ const agent = (kind === "durable" ? createDurableAgent : createEventedAgent)({ agent: new Agent({
3488
+ id: "usage-agent",
3489
+ name: "Usage agent",
3490
+ instructions: "Unused",
3491
+ model: fixture.model
3492
+ }) });
3493
+ mastra = new Mastra$1({
3494
+ agents: { agent },
3495
+ storage: new InMemoryStore(),
3496
+ logger: false
3497
+ });
3498
+ server = await config.startServer(mastra, () => {});
3499
+ const runId = `observe-usage-${kind}-${explicit}`;
3500
+ const usage = {
3501
+ inputTokens: 1,
3502
+ outputTokens: 2,
3503
+ totalTokens: 3
3504
+ };
3505
+ const raw = { source: "first step" };
3506
+ const steps = [{ usage: {
3507
+ ...usage,
3508
+ raw
3509
+ } }, { usage }];
3510
+ for (const step of steps) await agent.pubsub.publish(AGENT_STREAM_TOPIC(runId), {
3511
+ runId,
3512
+ type: "chunk",
3513
+ data: {
3514
+ type: "step-finish",
3515
+ runId,
3516
+ from: "AGENT",
3517
+ payload: {
3518
+ output: step,
3519
+ stepResult: {
3520
+ reason: "stop",
3521
+ warnings: [],
3522
+ isContinued: false
3523
+ },
3524
+ metadata: {}
3525
+ }
3526
+ }
3527
+ });
3528
+ await agent.pubsub.publish(AGENT_STREAM_TOPIC(runId), {
3529
+ runId,
3530
+ type: "finish",
3531
+ data: {
3532
+ output: {
3533
+ text: "",
3534
+ steps,
3535
+ usage: {
3536
+ ...usage,
3537
+ ...explicit ? { raw: { source: "finish" } } : {}
3538
+ }
3539
+ },
3540
+ stepResult: { reason: "stop" }
3541
+ }
3542
+ });
3543
+ const reference = createDurableAgentStream({
3544
+ pubsub: agent.pubsub,
3545
+ runId,
3546
+ messageId: "reference",
3547
+ model: {
3548
+ version: "v3",
3549
+ modelId: void 0,
3550
+ provider: void 0
3551
+ }
3552
+ });
3553
+ let expected;
3554
+ try {
3555
+ for await (const chunk of reference.output.fullStream) if (chunk.type === "finish") {
3556
+ const serialized = serializeStreamChunk(chunk);
3557
+ if (!serialized.ok) throw serialized.error;
3558
+ expected = JSON.parse(serialized.json).payload.output.usage;
3559
+ }
3560
+ } finally {
3561
+ await reference.cleanup();
3562
+ }
3563
+ expect(expected).toEqual({
3564
+ ...usage,
3565
+ raw
3566
+ });
3567
+ const finish = (await collectPublicFrames(await fetch(`${server.baseUrl}/api/agents/agent/observe`, {
3568
+ method: "POST",
3569
+ headers: { "content-type": "application/json" },
3570
+ body: JSON.stringify({ runId })
3571
+ }))).find((frame) => frame.type === "finish");
3572
+ expect(finish?.payload.output.usage).toEqual(expected);
3573
+ });
3574
+ it("drains replay before a rejecting error without emitting DONE (COR-1498)", async () => {
3575
+ fixture = await config.setupModel();
3576
+ const agent = (kind === "durable" ? createDurableAgent : createEventedAgent)({ agent: new Agent({
3577
+ id: "reject-agent",
3578
+ name: "Reject agent",
3579
+ instructions: "Unused",
3580
+ model: fixture.model
3581
+ }) });
3582
+ mastra = new Mastra$1({
3583
+ agents: { agent },
3584
+ storage: new InMemoryStore(),
3585
+ logger: false
3586
+ });
3587
+ server = await config.startServer(mastra, () => {});
3588
+ const runId = `observe-reject-${kind}`;
3589
+ const prefix = {
3590
+ type: "text-delta",
3591
+ runId,
3592
+ from: "AGENT",
3593
+ payload: { text: "before rejection" }
3594
+ };
3595
+ await agent.pubsub.publish(AGENT_STREAM_TOPIC(runId), {
3596
+ runId,
3597
+ type: "chunk",
3598
+ data: prefix
3599
+ });
3600
+ await agent.pubsub.publish(AGENT_STREAM_TOPIC(runId), {
3601
+ runId,
3602
+ type: "error",
3603
+ data: {
3604
+ delivery: "reject",
3605
+ error: {
3606
+ name: "Error",
3607
+ message: "Run superseded"
3608
+ }
3609
+ }
3610
+ });
3611
+ const response = await fetch(`${server.baseUrl}/api/agents/agent/observe`, {
3612
+ method: "POST",
3613
+ headers: { "content-type": "application/json" },
3614
+ body: JSON.stringify({ runId })
3615
+ });
3616
+ expect(response.status).toBe(200);
3617
+ const wire = await response.text();
3618
+ expect(wire).toContain(JSON.stringify(prefix));
3619
+ expect(wire).not.toContain("[DONE]");
3620
+ expect(wire).not.toContain("\"type\":\"error\"");
3621
+ });
3622
+ it("reattaches with the same public frames as stream, including tools and finish metadata (COR-1498)", async () => {
3623
+ fixture = await config.setupModel();
3624
+ const entered = deferred();
3625
+ const gate = deferred();
3626
+ const liveFrames = [];
3627
+ const tool = createTool({
3628
+ id: "lookup",
3629
+ description: "Look up an answer",
3630
+ inputSchema: z.object({}),
3631
+ execute: async () => {
3632
+ entered.resolve();
3633
+ await gate.promise;
3634
+ return { answer: 42 };
3635
+ }
3636
+ });
3637
+ let processedChunks = 0;
3638
+ const inner = new Agent({
3639
+ id: "observe-agent",
3640
+ name: "Observe agent",
3641
+ instructions: "Look up the answer.",
3642
+ model: fixture.model,
3643
+ tools: { lookup: tool },
3644
+ outputProcessors: [{
3645
+ id: "count-output-chunks",
3646
+ async processOutputStream({ part }) {
3647
+ processedChunks++;
3648
+ return part;
3649
+ }
3650
+ }]
3651
+ });
3652
+ const agent = (kind === "durable" ? createDurableAgent : createEventedAgent)({
3653
+ agent: inner,
3654
+ cleanupTimeoutMs: 6e4
3655
+ });
3656
+ mastra = new Mastra$1({
3657
+ agents: { agent },
3658
+ storage: new InMemoryStore(),
3659
+ logger: false
3660
+ });
3661
+ server = await config.startServer(mastra, () => {});
3662
+ fixture.addResponse(0, {
3663
+ content: "Looking up",
3664
+ toolCalls: [{
3665
+ id: "lookup-1",
3666
+ name: "lookup",
3667
+ arguments: {}
3668
+ }]
3669
+ });
3670
+ fixture.addResponse(1, { content: "The answer is 42." });
3671
+ const runId = `observe-parity-${kind}`;
3672
+ const base = `${server.baseUrl}/api/agents/agent`;
3673
+ const post = async (route, body) => {
3674
+ const response = await fetch(`${base}/${route}`, {
3675
+ method: "POST",
3676
+ headers: { "content-type": "application/json" },
3677
+ body: JSON.stringify(body)
3678
+ });
3679
+ expect(response.status).toBe(200);
3680
+ return response;
3681
+ };
3682
+ const original = collectPublicFrames(await post("stream", {
3683
+ messages: "Find the answer",
3684
+ runId,
3685
+ maxSteps: 3
3686
+ }));
3687
+ try {
3688
+ await entered.promise;
3689
+ const live = collectPublicFrames(await post("observe", {
3690
+ runId,
3691
+ offset: 0
3692
+ }), (frame) => {
3693
+ liveFrames.push(frame);
3694
+ });
3695
+ await expect.poll(() => liveFrames.some((frame) => frame.type === "tool-call"), { timeout: 2e3 }).toBe(true);
3696
+ await (await post("observe", { runId })).body.cancel();
3697
+ gate.resolve();
3698
+ const frames = await original;
3699
+ expect(await live).toEqual(frames);
3700
+ expect(frames.filter((frame) => frame.type === "text-delta").map((frame) => frame.payload.text).join("")).toBe("Looking upThe answer is 42.");
3701
+ expect(frames.some((frame) => frame.type === "tool-result")).toBe(true);
3702
+ expect(frames.filter((frame) => frame.type === "step-start")).toHaveLength(2);
3703
+ expect(frames.at(-1)).toMatchObject({
3704
+ type: "finish",
3705
+ runId,
3706
+ payload: { stepResult: { reason: "stop" } }
3707
+ });
3708
+ const processedAtFinish = processedChunks;
3709
+ expect(processedAtFinish).toBeGreaterThan(0);
3710
+ for (const offset of [void 0, 0]) {
3711
+ expect(await collectPublicFrames(await post("observe", {
3712
+ runId,
3713
+ offset
3714
+ }))).toEqual(frames);
3715
+ if (config.observeWithClient) expect(await config.observeWithClient(server.baseUrl, runId, offset)).toEqual(frames);
3716
+ }
3717
+ const delta = (await agent.pubsub.getHistory(AGENT_STREAM_TOPIC(runId))).find((event) => event.type === "chunk" && event.data?.type === "text-delta");
3718
+ expect(delta).toBeDefined();
3719
+ const firstDelta = frames.findIndex((frame) => frame.type === "text-delta");
3720
+ expect(await collectPublicFrames(await post("observe", {
3721
+ runId,
3722
+ offset: delta.index
3723
+ }))).toEqual(frames.slice(firstDelta));
3724
+ expect(await collectPublicFrames(await post("observe", {
3725
+ runId,
3726
+ offset: delta.index + 1
3727
+ }))).toEqual(frames.slice(firstDelta + 1));
3728
+ if (config.observeWithClient) expect(await config.observeWithClient(server.baseUrl, runId, delta.index)).toEqual(frames.slice(firstDelta));
3729
+ expect(processedChunks).toBe(processedAtFinish);
3730
+ } finally {
3731
+ gate.resolve();
3732
+ await original;
3733
+ }
3734
+ });
3735
+ }
3044
3736
  for (const route of [
3045
3737
  "stream",
3046
3738
  "stream-alias",
@@ -3285,8 +3977,7 @@ function createDurableDisconnectTestSuite(config) {
3285
3977
  }
3286
3978
  });
3287
3979
  }
3288
- //#endregion
3289
- //#region src/mcp-route-test-suite.ts
3980
+ // src/mcp-route-test-suite.ts
3290
3981
  /**
3291
3982
  * Creates a standardized integration test suite for MCP registry routes
3292
3983
  *
@@ -3538,8 +4229,7 @@ function createMCPRouteTestSuite(config) {
3538
4229
  });
3539
4230
  });
3540
4231
  }
3541
- //#endregion
3542
- //#region src/native-mcp-fixture.ts
4232
+ // src/native-mcp-fixture.ts
3543
4233
  const unavailable = (feature) => async () => {
3544
4234
  throw new Error(`${feature} is not available on a 2026-07-28 server`);
3545
4235
  };
@@ -3691,8 +4381,7 @@ var NativeMCPFixture = class extends MCPServerBase {
3691
4381
  return { resources: [] };
3692
4382
  }
3693
4383
  };
3694
- //#endregion
3695
- //#region src/mcp-transport-test-suite.ts
4384
+ // src/mcp-transport-test-suite.ts
3696
4385
  /**
3697
4386
  * Creates a standardized integration test suite for MCP transport routes
3698
4387
  *
@@ -4142,8 +4831,7 @@ function createMCPTransportTestSuite(config) {
4142
4831
  });
4143
4832
  });
4144
4833
  }
4145
- //#endregion
4146
- //#region src/multipart-test-suite.ts
4834
+ // src/multipart-test-suite.ts
4147
4835
  /**
4148
4836
  * Creates a standardized test suite for multipart/form-data handling in server adapters.
4149
4837
  *
@@ -4466,8 +5154,7 @@ function createMultipartTestSuite(config) {
4466
5154
  });
4467
5155
  });
4468
5156
  }
4469
- //#endregion
4470
- //#region src/http-logging-test-suite.ts
5157
+ // src/http-logging-test-suite.ts
4471
5158
  /**
4472
5159
  * Creates a standardized test suite for HTTP logging across all server adapters.
4473
5160
  *
@@ -4655,8 +5342,7 @@ function createHttpLoggingTestSuite(config) {
4655
5342
  });
4656
5343
  });
4657
5344
  }
4658
- //#endregion
4659
- //#region src/body-limit-test-suite.ts
5345
+ // src/body-limit-test-suite.ts
4660
5346
  /**
4661
5347
  * Creates a standardized body-limit test suite for server adapters.
4662
5348
  *
@@ -4856,8 +5542,7 @@ function createBodyLimitTestSuite(config) {
4856
5542
  });
4857
5543
  });
4858
5544
  }
4859
- //#endregion
4860
- //#region src/custom-route-fga-test-suite.ts
5545
+ // src/custom-route-fga-test-suite.ts
4861
5546
  /**
4862
5547
  * Custom `registerApiRoute()` handlers read path params from the URL. FGA must
4863
5548
  * authorize that same resource, so a query or body field named like a path
@@ -4947,7 +5632,6 @@ function createCustomRouteFGATestSuite(config) {
4947
5632
  });
4948
5633
  });
4949
5634
  }
4950
- //#endregion
4951
- export { consumeSSEStream, createBodyLimitTestSuite, createCustomRouteFGATestSuite, createDefaultTestContext, createDurableDisconnectTestSuite, createHttpLoggingTestSuite, createMCPRouteTestSuite, createMCPTransportTestSuite, createMultipartTestSuite, createRouteAdapterTestSuite, createStreamWithSensitiveData, createStreamWithUnserializableChunk, expectSerializedStreamChunks };
5635
+ export { consumeSSEStream, createBodyLimitTestSuite, createCustomRouteFGATestSuite, createDefaultTestContext, createDurableDisconnectTestSuite, createHttpLoggingTestSuite, createMCPRouteTestSuite, createMCPTransportTestSuite, createMultipartTestSuite, createRouteAdapterTestSuite, createStreamWithSensitiveData, createStreamWithUnserializableChunk, createStructuredWakeTestSuite, expectSerializedStreamChunks };
4952
5636
 
4953
5637
  //# sourceMappingURL=index.js.map