Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.
import { claudeMessage } from "./test-support/claudeMessages.ts";
import { ProviderDriverKind } from "@akeru/contracts";
import { assert, describe, it } from "@effect/vitest";
import * as Effect from "effect/Effect";
import * as Fiber from "effect/Fiber";
import * as Random from "effect/Random";
import * as Stream from "effect/Stream";
import {
ClaudeAdapter,
makeHarness,
makeDeterministicRandomService,
THREAD_ID,
} from "./test-support/claudeAdapterHarness.ts";
describe("ClaudeAdapterLive", () => {
it.effect("creates a fresh assistant message when Claude reuses a text block index", () => {
const harness = makeHarness();
return Effect.gen(function* () {
const adapter = yield* ClaudeAdapter;
const runtimeEventsFiber = yield* Stream.take(adapter.streamEvents, 9).pipe(
Stream.runCollect,
Effect.forkChild,
);
const session = yield* adapter.startSession({
threadId: THREAD_ID,
provider: ProviderDriverKind.make("claudeAgent"),
runtimeMode: "full-access",
});
yield* adapter.sendTurn({
threadId: session.threadId,
input: "hello",
attachments: [],
});
harness.query.emit(
claudeMessage({
type: "stream_event",
session_id: "sdk-session-reused-text-index",
uuid: "stream-reused-start-1",
parent_tool_use_id: null,
event: {
type: "content_block_start",
index: 0,
content_block: {
type: "text",
text: "",
},
},
}),
);
harness.query.emit(
claudeMessage({
type: "stream_event",
session_id: "sdk-session-reused-text-index",
uuid: "stream-reused-delta-1",
parent_tool_use_id: null,
event: {
type: "content_block_delta",
index: 0,
delta: {
type: "text_delta",
text: "First",
},
},
}),
);
harness.query.emit(
claudeMessage({
type: "stream_event",
session_id: "sdk-session-reused-text-index",
uuid: "stream-reused-stop-1",
parent_tool_use_id: null,
event: {
type: "content_block_stop",
index: 0,
},
}),
);
harness.query.emit(
claudeMessage({
type: "stream_event",
session_id: "sdk-session-reused-text-index",
uuid: "stream-reused-start-2",
parent_tool_use_id: null,
event: {
type: "content_block_start",
index: 0,
content_block: {
type: "text",
text: "",
},
},
}),
);
harness.query.emit(
claudeMessage({
type: "stream_event",
session_id: "sdk-session-reused-text-index",
uuid: "stream-reused-delta-2",
parent_tool_use_id: null,
event: {
type: "content_block_delta",
index: 0,
delta: {
type: "text_delta",
text: "Second",
},
},
}),
);
harness.query.emit(
claudeMessage({
type: "stream_event",
session_id: "sdk-session-reused-text-index",
uuid: "stream-reused-stop-2",
parent_tool_use_id: null,
event: {
type: "content_block_stop",
index: 0,
},
}),
);
harness.query.emit(
claudeMessage({
type: "result",
subtype: "success",
is_error: false,
errors: [],
session_id: "sdk-session-reused-text-index",
uuid: "result-reused-text-index",
}),
);
const runtimeEvents = Array.from(yield* Fiber.join(runtimeEventsFiber));
assert.deepEqual(
runtimeEvents.map((event) => event.type),
[
"session.started",
"session.configured",
"session.state.changed",
"turn.started",
"thread.started",
"content.delta",
"item.completed",
"content.delta",
"item.completed",
],
);
const assistantDeltas = runtimeEvents.filter(
(event) => event.type === "content.delta" && event.payload.streamKind === "assistant_text",
);
assert.equal(assistantDeltas.length, 2);
if (assistantDeltas.length !== 2) {
return;
}
const [firstAssistantDelta, secondAssistantDelta] = assistantDeltas;
assert.equal(firstAssistantDelta?.type, "content.delta");
assert.equal(secondAssistantDelta?.type, "content.delta");
if (
firstAssistantDelta?.type !== "content.delta" ||
secondAssistantDelta?.type !== "content.delta"
) {
return;
}
assert.equal(firstAssistantDelta.payload.delta, "First");
assert.equal(secondAssistantDelta.payload.delta, "Second");
assert.notEqual(firstAssistantDelta.itemId, secondAssistantDelta.itemId);
const assistantCompletions = runtimeEvents.filter(
(event) =>
event.type === "item.completed" && event.payload.itemType === "assistant_message",
);
assert.equal(assistantCompletions.length, 2);
assert.equal(String(assistantCompletions[0]?.itemId), String(firstAssistantDelta.itemId));
assert.equal(String(assistantCompletions[1]?.itemId), String(secondAssistantDelta.itemId));
assert.notEqual(
String(assistantCompletions[0]?.itemId),
String(assistantCompletions[1]?.itemId),
);
}).pipe(
Effect.provideService(Random.Random, makeDeterministicRandomService()),
Effect.provide(harness.layer),
);
});
});
describe("ClaudeAdapterLive", () => {
it.effect("segments Claude assistant text blocks around tool calls", () => {
const harness = makeHarness();
return Effect.gen(function* () {
const adapter = yield* ClaudeAdapter;
const runtimeEventsFiber = yield* Stream.take(adapter.streamEvents, 13).pipe(
Stream.runCollect,
Effect.forkChild,
);
const session = yield* adapter.startSession({
threadId: THREAD_ID,
provider: ProviderDriverKind.make("claudeAgent"),
runtimeMode: "full-access",
});
yield* adapter.sendTurn({
threadId: session.threadId,
input: "hello",
attachments: [],
});
harness.query.emit(
claudeMessage({
type: "stream_event",
session_id: "sdk-session-interleaved",
uuid: "stream-text-1-start",
parent_tool_use_id: null,
event: {
type: "content_block_start",
index: 0,
content_block: {
type: "text",
text: "",
},
},
}),
);
harness.query.emit(
claudeMessage({
type: "stream_event",
session_id: "sdk-session-interleaved",
uuid: "stream-text-1-delta",
parent_tool_use_id: null,
event: {
type: "content_block_delta",
index: 0,
delta: {
type: "text_delta",
text: "First message.",
},
},
}),
);
harness.query.emit(
claudeMessage({
type: "stream_event",
session_id: "sdk-session-interleaved",
uuid: "stream-text-1-stop",
parent_tool_use_id: null,
event: {
type: "content_block_stop",
index: 0,
},
}),
);
harness.query.emit(
claudeMessage({
type: "stream_event",
session_id: "sdk-session-interleaved",
uuid: "stream-tool-start",
parent_tool_use_id: null,
event: {
type: "content_block_start",
index: 1,
content_block: {
type: "tool_use",
id: "tool-interleaved-1",
name: "Grep",
input: {
pattern: "assistant",
path: "src",
},
},
},
}),
);
harness.query.emit(
claudeMessage({
type: "stream_event",
session_id: "sdk-session-interleaved",
uuid: "stream-tool-stop",
parent_tool_use_id: null,
event: {
type: "content_block_stop",
index: 1,
},
}),
);
harness.query.emit(
claudeMessage({
type: "user",
session_id: "sdk-session-interleaved",
uuid: "user-tool-result-interleaved",
parent_tool_use_id: null,
message: {
role: "user",
content: [
{
type: "tool_result",
tool_use_id: "tool-interleaved-1",
content: "src/example.ts:1:assistant",
},
],
},
}),
);
harness.query.emit(
claudeMessage({
type: "stream_event",
session_id: "sdk-session-interleaved",
uuid: "stream-text-2-start",
parent_tool_use_id: null,
event: {
type: "content_block_start",
index: 2,
content_block: {
type: "text",
text: "",
},
},
}),
);
harness.query.emit(
claudeMessage({
type: "stream_event",
session_id: "sdk-session-interleaved",
uuid: "stream-text-2-delta",
parent_tool_use_id: null,
event: {
type: "content_block_delta",
index: 2,
delta: {
type: "text_delta",
text: "Second message.",
},
},
}),
);
harness.query.emit(
claudeMessage({
type: "stream_event",
session_id: "sdk-session-interleaved",
uuid: "stream-text-2-stop",
parent_tool_use_id: null,
event: {
type: "content_block_stop",
index: 2,
},
}),
);
harness.query.emit(
claudeMessage({
type: "result",
subtype: "success",
is_error: false,
errors: [],
session_id: "sdk-session-interleaved",
uuid: "result-interleaved",
}),
);
const runtimeEvents = Array.from(yield* Fiber.join(runtimeEventsFiber));
assert.deepEqual(
runtimeEvents.map((event) => event.type),
[
"session.started",
"session.configured",
"session.state.changed",
"turn.started",
"thread.started",
"content.delta",
"item.completed",
"item.started",
"item.updated",
"item.completed",
"content.delta",
"item.completed",
"turn.completed",
],
);
const assistantTextDeltas = runtimeEvents.filter(
(event) => event.type === "content.delta" && event.payload.streamKind === "assistant_text",
);
assert.equal(assistantTextDeltas.length, 2);
if (assistantTextDeltas.length !== 2) {
return;
}
const [firstAssistantDelta, secondAssistantDelta] = assistantTextDeltas;
if (!firstAssistantDelta || !secondAssistantDelta) {
return;
}
assert.notEqual(String(firstAssistantDelta.itemId), String(secondAssistantDelta.itemId));
const firstAssistantCompletedIndex = runtimeEvents.findIndex(
(event) =>
event.type === "item.completed" &&
event.payload.itemType === "assistant_message" &&
String(event.itemId) === String(firstAssistantDelta.itemId),
);
const toolStartedIndex = runtimeEvents.findIndex((event) => event.type === "item.started");
const secondAssistantDeltaIndex = runtimeEvents.findIndex(
(event) =>
event.type === "content.delta" &&
event.payload.streamKind === "assistant_text" &&
String(event.itemId) === String(secondAssistantDelta.itemId),
);
assert.equal(
firstAssistantCompletedIndex >= 0 &&
toolStartedIndex >= 0 &&
secondAssistantDeltaIndex >= 0 &&
firstAssistantCompletedIndex < toolStartedIndex &&
toolStartedIndex < secondAssistantDeltaIndex,
true,
);
}).pipe(
Effect.provideService(Random.Random, makeDeterministicRandomService()),
Effect.provide(harness.layer),
);
});
});