Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
4 changes: 2 additions & 2 deletions apps/server/src/kin/chat/KinChatService.ts
Original file line number Diff line number Diff line change
Expand Up @@ -196,7 +196,7 @@ const requireRecord = Effect.fn("KinChatService.requireRecord")(function* <A, E,

const make = Effect.gen(function* () {
const floor = yield* Floor.KinFloor;
const shadow = yield* Effect.serviceOption(JudgeShadow);
const shadow = yield* JudgeShadow;
const cards = yield* TaskCard.TaskCardIndex;
const repo = yield* Repository.KinChatRepository;
const hub = yield* Hub.KinChatHub;
Expand Down Expand Up @@ -369,7 +369,7 @@ const make = Effect.gen(function* () {
if (message.messageId !== messageId) return message;
if (message.author._tag === "human") {
const decision = yield* floor.open(message, yield* requireRecord(repo.getChat(member)));
if (Option.isSome(shadow)) yield* shadow.value.observe(message, decision);
yield* shadow.observe(message, decision);
}
if (input.publish === false) return message;
yield* hub.publish({ type: "message.posted", orgId: identity.orgId, message });
Expand Down
5 changes: 4 additions & 1 deletion apps/server/src/kin/chat/TaskCard.testkit.ts
Original file line number Diff line number Diff line change
@@ -1,8 +1,11 @@
import * as JudgeShadow from "../floor/JudgeShadow.ts";
import { EnvironmentId } from "@t3tools/contracts";
import { ServerEnvironment } from "../../environment/ServerEnvironment.ts";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";

export const environment = Layer.mock(ServerEnvironment)({
const serverEnvironment = Layer.mock(ServerEnvironment)({
getEnvironmentId: Effect.succeed(EnvironmentId.make("environment")),
});

export const environment = Layer.merge(serverEnvironment, JudgeShadow.layerOff);
3 changes: 3 additions & 0 deletions apps/server/src/kin/chat/layer.ts
Original file line number Diff line number Diff line change
@@ -1,3 +1,5 @@
import * as JudgeShadow from "../floor/JudgeShadow.ts";
import * as NoopJudge from "../floor/NoopJudge.ts";
import * as Layer from "effect/Layer";
import * as Budget from "../lead/KinBudget.ts";
import * as Queue from "../lead/KinEventQueue.ts";
Expand All @@ -13,6 +15,7 @@ export const layer = Layer.mergeAll(
Budget.layer.pipe(Layer.provideMerge(Queue.layer), Layer.provide(Cache.layer)),
KinIdentity.layer.pipe(Layer.provide(KinIdentityConfig.layer)),
).pipe(
Layer.provide(JudgeShadow.layer.pipe(Layer.provide(NoopJudge.layer))),
Layer.provideMerge(Hub.layer),
Layer.provideMerge(Repository.layer),
Layer.provide(KinPersistence.layer),
Expand Down
4 changes: 4 additions & 0 deletions apps/server/src/kin/chat/rpcHandlers.test.ts
Original file line number Diff line number Diff line change
@@ -1,3 +1,4 @@
import * as JudgeShadow from "../floor/JudgeShadow.ts";
import { dormantLeadDependencies } from "../lead/layer.testkit.ts";
import { assert, it } from "@effect/vitest";
import * as NodeServices from "@effect/platform-node/NodeServices";
Expand Down Expand Up @@ -330,6 +331,7 @@ it.effect(
const service = yield* KinChatService.pipe(
Effect.provide(
Layer.fresh(Service.layer).pipe(
Layer.provide(JudgeShadow.layerOff),
Layer.provide(Layer.succeed(Repository.KinChatRepository, interceptedRepo)),
Layer.provide(
Layer.succeed(Hub.KinChatHub, {
Expand Down Expand Up @@ -439,6 +441,7 @@ it.effect("subscribes before the list snapshot and drops buffered state already
const service = yield* KinChatService.pipe(
Effect.provide(
Layer.fresh(Service.layer).pipe(
Layer.provide(JudgeShadow.layerOff),
Layer.provide(
Layer.succeed(
Repository.KinChatRepository,
Expand Down Expand Up @@ -507,6 +510,7 @@ it.effect("drops a failed waiting read without ending the chat list stream", ()
const service = yield* KinChatService.pipe(
Effect.provide(
Layer.fresh(Service.layer).pipe(
Layer.provide(JudgeShadow.layerOff),
Layer.provide(
Layer.succeed(Repository.KinChatRepository, {
...repo,
Expand Down
232 changes: 212 additions & 20 deletions apps/server/src/kin/floor/JudgeShadow.test.ts
Original file line number Diff line number Diff line change
@@ -1,5 +1,12 @@
import { assert, describe, it } from "@effect/vitest";
import { KinAgentId, KinChatId, KinMemberId, KinOrgId, KinPersonId } from "@t3tools/contracts";
import {
KinAgentId,
KinChatId,
KinMemberId,
KinMessageId,
KinOrgId,
KinPersonId,
} from "@t3tools/contracts";
import * as Schema from "effect/Schema";
import * as Clock from "effect/Clock";
import * as Deferred from "effect/Deferred";
Expand All @@ -11,6 +18,7 @@ import * as Option from "effect/Option";
import * as Stream from "effect/Stream";
import * as TestClock from "effect/testing/TestClock";
import * as SqlClient from "effect/sql/SqlClient";
import type * as Statement from "effect/sql/Statement";
import { environment } from "../chat/TaskCard.testkit.ts";
import { authorityLayer } from "../chat/WakeupAuthority.testkit.ts";
import * as Repository from "../chat/KinChatRepository.ts";
Expand All @@ -30,9 +38,17 @@ const timestamp = "1970-01-01T00:00:00.000Z";
const person = { _tag: "person" as const, orgId, personId };
const database = Repository.layer.pipe(Layer.provideMerge(authorityLayer));
const dependencies = Hub.layer.pipe(Layer.provideMerge(database));
const testLayer = (judge: Layer.Layer<Judge>) =>
const testLayer = (
judge: Layer.Layer<Judge>,
sqlLayer:
| Layer.Layer<SqlClient.SqlClient, never, SqlClient.SqlClient>
| Layer.Layer<never> = Layer.empty,
off = false,
) =>
Chat.layer.pipe(
Layer.provideMerge(Shadow.layer.pipe(Layer.provide(judge))),
Layer.provideMerge(
(off ? Shadow.layerOff : Shadow.layer).pipe(Layer.provide(judge), Layer.provide(sqlLayer)),
),
Layer.provideMerge(dependencies),
Layer.provide(environment),
);
Expand Down Expand Up @@ -83,15 +99,43 @@ const seed = Effect.gen(function* () {
mutedUntil: null,
});
});
const send = (key: string) =>
const send = (key: string, grant = true) =>
Effect.flatMap(Chat.KinChatService, (service) =>
service.send(person, {
chatId,
clientMessageId: key,
body: `Untrusted human text ${key}`,
mentions: [agentMemberId],
mentions: grant ? [agentMemberId] : [],
}),
);
const otherChatId = KinChatId.make("other-group");
const sendInOtherChat = Effect.gen(function* () {
const repo = yield* Repository.KinChatRepository;
yield* repo.createChat({
orgId,
chatId: otherChatId,
kind: "team_group",
title: "Other",
teamId: null,
directKey: null,
lastMessageAt: null,
createdAt: timestamp,
archivedAt: null,
});
yield* repo.addMember({
orgId,
chatId: otherChatId,
memberId: KinMemberId.make("owner-other"),
principal: { _tag: "person", personId },
role: "owner",
joinedAt: timestamp,
leftAt: null,
mutedUntil: null,
});
return yield* Effect.flatMap(Chat.KinChatService, (service) =>
service.send(person, { chatId: otherChatId, clientMessageId: "other", body: "Other chat" }),
);
});
const logs = Effect.gen(function* () {
const sql = yield* SqlClient.SqlClient;
return yield* sql<{
Expand All @@ -106,8 +150,11 @@ const logs = Effect.gen(function* () {
});
const floor = Effect.gen(function* () {
const sql = yield* SqlClient.SqlClient;
return yield* sql`SELECT run_id, opened_by, state, agent_turns, last_speaker FROM kin_floor_runs
WHERE org_id = ${orgId} AND chat_id = ${chatId} ORDER BY opened_at, run_id`;
return {
runs: yield* sql`SELECT * FROM kin_floor_runs WHERE org_id = ${orgId} AND chat_id = ${chatId} ORDER BY run_id`,
grants:
yield* sql`SELECT * FROM kin_floor_grants WHERE org_id = ${orgId} AND chat_id = ${chatId} ORDER BY token`,
};
});

describe("JudgeShadow", () => {
Expand Down Expand Up @@ -151,43 +198,184 @@ describe("JudgeShadow", () => {
}).pipe(Effect.provide(testLayer(NoopJudge.layer))),
);

it.effect("the record deadline includes the log write", () =>
Effect.gen(function* () {
const modelEntered = yield* Deferred.make<void>();
const modelResult = yield* Deferred.make<JudgeVerdict>();
const writeEntered = yield* Deferred.make<void>();
const writeResult = yield* Deferred.make<void>();
const judge = Layer.succeed(Judge, {
name: "blocked-write",
judge: () =>
Deferred.succeed(modelEntered, undefined).pipe(
Effect.andThen(Deferred.await(modelResult)),
),
});
const sqlLayer = Layer.effect(
SqlClient.SqlClient,
Effect.map(
SqlClient.SqlClient,
(sql) =>
new Proxy(sql, {
apply(target, thisArg, args) {
const query = Reflect.apply(target, thisArg, args) as Statement.Statement<never>;
if (String(args[0]).includes("INSERT INTO kin_judge_log"))
return Deferred.succeed(writeEntered, undefined).pipe(
Effect.andThen(Deferred.await(writeResult)),
Effect.andThen(query),
);
return query;
},
}),
),
);
yield* Effect.gen(function* () {
yield* seed;
yield* send("deadline");
yield* Deferred.await(modelEntered);
yield* TestClock.adjust(2000);
yield* Deferred.succeed(modelResult, {
needsResponse: { value: false, confidence: 0 },
role: { value: null, confidence: 0 },
urgency: { value: "normal", confidence: 0 },
needsHumanDecision: { value: false, confidence: 0 },
commitment: { value: { kind: "none", text: null }, confidence: 0 },
});
yield* Deferred.await(writeEntered);
const drained = yield* (yield* Shadow.JudgeShadow).drain.pipe(Effect.forkScoped);
yield* TestClock.adjust(1000);
assert.isTrue(drained.pollUnsafe() !== undefined);
yield* Deferred.succeed(writeResult, undefined);
yield* Fiber.join(drained);
assert.deepStrictEqual(yield* logs, []);
}).pipe(Effect.provide(testLayer(judge, sqlLayer)));
}),
);

it.effect.each([
"extra",
"text",
"name",
"agent",
"chat",
"org",
"message",
"crossChat",
"null",
] as const)("drops records outside the allowlist: %s", (invalid) =>
Effect.gen(function* () {
const verdict: JudgeVerdict = {
needsResponse: { value: true, confidence: 1 },
role: { value: "lead", confidence: 1 },
urgency: { value: "normal", confidence: 1 },
needsHumanDecision: { value: false, confidence: 1 },
commitment: {
value: { kind: "promise", text: invalid === "text" ? "x".repeat(1001) : null },
confidence: 1,
},
};
const judge = Layer.succeed(Judge, {
name: invalid === "name" ? "x".repeat(101) : "boundary",
judge: () =>
Effect.succeed(
invalid === "null"
? (null as unknown as JudgeVerdict)
: invalid === "extra"
? { ...verdict, token: "not-authority" }
: verdict,
),
});
yield* Effect.gen(function* () {
yield* seed;
const message = invalid === "crossChat" ? yield* sendInOtherChat : yield* send("boundary");
const shadow = yield* Shadow.JudgeShadow;
yield* shadow.drain;
const sql = yield* SqlClient.SqlClient;
yield* sql`DELETE FROM kin_judge_log`;
const before = yield* floor;
yield* shadow.observe(
{
...message,
chatId: invalid === "chat" ? KinChatId.make("other") : chatId,
orgId: invalid === "org" ? KinOrgId.make("other") : orgId,
messageId: invalid === "message" ? KinMessageId.make("missing") : message.messageId,
},
{ _tag: "grant", agentId: invalid === "agent" ? KinAgentId.make("outsider") : agentId },
);
yield* shadow.drain;
assert.deepStrictEqual(yield* logs, []);
assert.deepStrictEqual(yield* floor, before);
}).pipe(Effect.provide(testLayer(judge)));
}),
);

it.effect.prop(
"arbitrary verdicts cannot change a group floor decision",
{
grant: Schema.Boolean,
off: Schema.Boolean,
response: Schema.Boolean,
human: Schema.Boolean,
role: Schema.NullOr(Schema.Literals(["lead", "qa", "release"])),
urgency: Schema.Literals(["low", "normal", "high"]),
confidence: Schema.Number.check(Schema.isBetween({ minimum: 0, maximum: 1 })),
confidence: Schema.Union([
Schema.Number.check(Schema.isBetween({ minimum: 0, maximum: 1 })),
Schema.Literals([-1, 2]),
]),
commitment: Schema.Literals(["none", "defer", "promise"]),
},
(values) =>
Effect.gen(function* () {
const ready = yield* Deferred.make<void>();
// Normalise -0 so the JSON round-trip compares equal.
const confidence = values.confidence + 0;
const verdict: JudgeVerdict = {
needsResponse: { value: values.response, confidence: Math.abs(values.confidence) },
needsHumanDecision: { value: values.human, confidence: Math.abs(values.confidence) },
role: { value: values.role, confidence: Math.abs(values.confidence) },
urgency: { value: values.urgency, confidence: Math.abs(values.confidence) },
needsResponse: {
value: values.response,
confidence,
},
needsHumanDecision: {
value: values.human,
confidence,
},
role: { value: values.role, confidence },
urgency: {
value: values.urgency,
confidence,
},
commitment: {
value: { kind: values.commitment, text: null },
confidence: Math.abs(values.confidence),
confidence,
},
};
const judge = Layer.succeed(Judge, {
name: "generated",
judge: (input) => Effect.succeed({ ...verdict, untrustedExtra: input.text }),
judge: () => Deferred.await(ready).pipe(Effect.as(verdict)),
});
yield* Effect.gen(function* () {
yield* seed;
yield* send("generated");
yield* send("generated", values.grant);
const before = yield* floor;
yield* Deferred.succeed(ready, undefined);
yield* (yield* Shadow.JudgeShadow).drain;
assert.deepStrictEqual(yield* floor, before);
const [row] = yield* logs;
if (values.off || values.confidence < 0 || values.confidence > 1) {
assert.isUndefined(row);
return;
}
assert.isNull(row!.error);
assert.deepStrictEqual(JSON.parse(row!.floor_decision_json), { _tag: "grant", agentId });
assert.deepStrictEqual(JSON.parse(row!.verdict_json!), verdict);
}).pipe(Effect.provide(testLayer(judge)));
assert.deepStrictEqual(
JSON.parse(row!.floor_decision_json),
values.grant ? { _tag: "grant", agentId } : { _tag: "wait" },
);
const stored: JudgeVerdict = JSON.parse(row!.verdict_json!);
assert.deepStrictEqual(stored, verdict);
for (const score of Object.values(stored)) {
assert.isAtLeast(score.confidence, 0);
assert.isAtMost(score.confidence, 1);
}
}).pipe(Effect.provide(testLayer(judge, Layer.empty, values.off)));
}),
{ arbitrary: { runs: 20 } },
);
Expand Down Expand Up @@ -248,8 +436,12 @@ describe("JudgeShadow", () => {
yield* (yield* Shadow.JudgeShadow).drain;
assert.deepStrictEqual(yield* floor, before);
const [row] = yield* logs;
assert.strictEqual(row!.error, mode === "slow" ? "timeout" : "judge_error");
assert.strictEqual(row!.latency_ms, mode === "slow" ? 3000 : 0);
if (mode === "slow") {
assert.isUndefined(row);
return;
}
assert.strictEqual(row!.error, "judge_error");
assert.strictEqual(row!.latency_ms, 0);
assert.isNull(row!.verdict_json);
}).pipe(Effect.provide(testLayer(judge)));
}),
Expand Down
Loading