Add missing test coverage: session.wait, hosted tool validation, debug streaming, baseUrl

- session.wait(): returns result, multi-turn, throws without send(), throws on closed
- validateAgent: hosted + function tool name collision, empty tools
- debug mode: stream(), session debug option
- resolveResponsesBaseUrl: standard, foundry, full_url with/without /responses

683 total unit tests pass.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: tylergibbs1

packages/stratus-sdk/tests/azure/endpoint.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, test } from "bun:test";
 import {
 	detectEndpointKind,
 	resolveChatCompletionsUrl,
+	resolveResponsesBaseUrl,
 	resolveResponsesUrl,
 } from "../../src/azure/endpoint";
 
@@ -124,3 +125,46 @@ describe("resolveResponsesUrl", () => {
 		expect(url).toBe("https://myresource.openai.azure.com/openai/v1/responses");
 	});
 });
+
+describe("resolveResponsesBaseUrl", () => {
+	test("standard endpoint", () => {
+		const url = resolveResponsesBaseUrl(
+			"https://myresource.openai.azure.com",
+			"2025-04-01-preview",
+		);
+		expect(url).toBe("https://myresource.openai.azure.com/openai/v1/responses");
+	});
+
+	test("foundry endpoint includes api-version", () => {
+		const url = resolveResponsesBaseUrl(
+			"https://myproject.services.ai.azure.com",
+			"2025-04-01-preview",
+		);
+		expect(url).toContain("api-version=2025-04-01-preview");
+		expect(url).toContain("/openai/responses");
+	});
+
+	test("full_url with /responses strips trailing path", () => {
+		const url = resolveResponsesBaseUrl(
+			"https://myresource.openai.azure.com/openai/v1/responses",
+			"ignored",
+		);
+		expect(url).toBe("https://myresource.openai.azure.com/openai/v1/responses");
+	});
+
+	test("full_url without /responses falls back to standard format", () => {
+		const url = resolveResponsesBaseUrl(
+			"https://myresource.openai.azure.com/openai/deployments/gpt-4o/chat/completions",
+			"ignored",
+		);
+		expect(url).toBe("https://myresource.openai.azure.com/openai/v1/responses");
+	});
+
+	test("full_url with /openai/deployments/ but no /responses falls back", () => {
+		const url = resolveResponsesBaseUrl(
+			"https://myresource.openai.azure.com/openai/deployments/gpt-4o/chat/completions?api-version=2025-03-01",
+			"ignored",
+		);
+		expect(url).toBe("https://myresource.openai.azure.com/openai/v1/responses");
+	});
+});

packages/stratus-sdk/tests/core/debug.test.ts

@@ -1,7 +1,8 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { z } from "zod";
 import { Agent } from "../../src/core/agent";
-import { run } from "../../src/core/run";
+import { run, stream } from "../../src/core/run";
+import { createSession } from "../../src/core/session";
 import { tool } from "../../src/core/tool";
 import { createMockModel, textResponse, toolCallResponse } from "../../src/testing/index";
 
@@ -66,4 +67,30 @@ describe("debug mode", () => {
 		expect(output).toContain("add");
 		expect(output).toContain("results");
 	});
+
+	test("logs with stream()", async () => {
+		const model = createMockModel([textResponse("Streamed!")]);
+		const agent = new Agent({ name: "streamer", model });
+
+		const { stream: s, result } = stream(agent, "Hi", { debug: true });
+		for await (const _event of s) {
+			// drain
+		}
+		await result;
+
+		const output = stderrOutput.join("");
+		expect(output).toContain("[stratus:model]");
+		expect(output).toContain("stream request to streamer");
+	});
+
+	test("logs with session debug option", async () => {
+		const model = createMockModel([textResponse("Session debug!")]);
+		const session = createSession({ model, debug: true });
+
+		session.send("Hi");
+		await session.wait();
+
+		const output = stderrOutput.join("");
+		expect(output).toContain("[stratus:model]");
+	});
 });

packages/stratus-sdk/tests/core/session.test.ts

@@ -337,3 +337,53 @@ describe("session", () => {
 		expect(s1.id).not.toBe(s2.id);
 	});
 });
+
+describe("session.wait()", () => {
+	test("returns result without manual stream draining", async () => {
+		const model = mockModel([{ content: "Hello from wait!", toolCalls: [] }]);
+		const session = createSession({ model });
+
+		session.send("Hi");
+		const result = await session.wait();
+
+		expect(result.output).toBe("Hello from wait!");
+	});
+
+	test("multi-turn with wait()", async () => {
+		const model = mockModel([
+			{ content: "First", toolCalls: [] },
+			{ content: "Second", toolCalls: [] },
+		]);
+		const session = createSession({ model });
+
+		session.send("Turn 1");
+		const r1 = await session.wait();
+		expect(r1.output).toBe("First");
+
+		session.send("Turn 2");
+		const r2 = await session.wait();
+		expect(r2.output).toBe("Second");
+	});
+
+	test("throws if called without send()", async () => {
+		const model = mockModel([
+			{ content: "First", toolCalls: [] },
+		]);
+		const session = createSession({ model });
+
+		// First: normal flow
+		session.send("Hi");
+		await session.wait();
+
+		// Second: no send() before wait()
+		expect(() => session.wait()).toThrow("No new message");
+	});
+
+	test("throws on closed session", async () => {
+		const model = mockModel([{ content: "Hi", toolCalls: [] }]);
+		const session = createSession({ model });
+		session.close();
+
+		expect(() => session.wait()).toThrow("closed");
+	});
+});

packages/stratus-sdk/tests/core/validate-agent.test.ts

@@ -108,4 +108,26 @@ describe("Agent constructor validation", () => {
 		expect(agent.name).toBe("good");
 		expect(agent.tools).toHaveLength(2);
 	});
+
+	test("detects collision between hosted tool and function tool with same name", () => {
+		const hostedTool = {
+			type: "hosted" as const,
+			name: "web_search_preview",
+			definition: { type: "web_search_preview" },
+		};
+		const functionTool = dummyTool("web_search_preview");
+
+		expect(
+			() =>
+				new Agent({
+					name: "collision",
+					tools: [hostedTool, functionTool],
+				}),
+		).toThrow("Duplicate tool name");
+	});
+
+	test("agent with no tools validates cleanly", () => {
+		const agent = new Agent({ name: "empty" });
+		expect(agent.tools).toHaveLength(0);
+	});
 });