@openshain/core 0.3.1 → 0.4.1

package/src/work/events.ts

@@ -42,6 +42,8 @@ export const TOOL_REJECTION_CODES = [
   "outside_workspace",
   "invalid_path",
   "limit_reached",
+  "denied",
+  "rejected_by_person",
 ] as const;
 
 export type ToolRejectionCode = (typeof TOOL_REJECTION_CODES)[number];
@@ -72,6 +74,29 @@ export interface EventPayloads {
   "tool.rejected": { callId: string; name: string; code: ToolRejectionCode; reason: string };
   "human.input_requested": { callId: string; question: string };
   "human.input_provided": { callId: string; answer: string };
+  /** A tool call the policy holds for a person's or a reviewer's approval. The work waits. */
+  "approval.requested": {
+    approvalId: string;
+    call: { callId: string; name: string; input: unknown };
+    ruleId: string;
+    kind: "approval" | "review";
+    approvers?: string[];
+    reviewer?: { role: string; name?: string };
+  };
+  /** The package handed to the reviewer: the call, what the work established, and the question. */
+  "review.requested": { approvalId: string; package: ReviewPackage };
+  /** The reviewer's answer. A decision id when they wrote one; absent when they refused. */
+  "review.decided": { approvalId: string; decisionId?: string };
+  /** A call that ran because an approved decision covers it. */
+  "decision.applied": { callId: string; decisionId: string };
+  /** The answer to an approval: approve runs the call, reject refuses it, modify runs it with the reviewer's input. */
+  "approval.decided": {
+    approvalId: string;
+    decision: "approve" | "reject" | "modify";
+    by: string;
+    comment?: string;
+    modifiedInput?: unknown;
+  };
   /** What the person said in a session. Becomes a user message in the projection. */
   "human.message": { text: string };
   /** A prompt command expanded for the model: its name, where it came from, and the text handed over. */
@@ -84,6 +109,23 @@ export interface EventPayloads {
   "work.failed": { reason: string; detail: string };
 }
 
+/** What a reviewer is asked to decide on, built from the work's own record. */
+export interface ReviewPackage {
+  approvalId: string;
+  workId: string;
+  action: { name: string; tool: string; input: unknown };
+  /** What the work established before this call: the tool calls it made. */
+  facts: string[];
+  /** Sources and company rules the work cited. Empty until knowledge is in. */
+  sources: { id: string; locator?: string; version?: string }[];
+  companyRules: { id: string; statement: string }[];
+  /** What the agent proposes, in its own words. */
+  proposal: string;
+  question: string;
+  requestedBy: string;
+  requestedAt: string;
+}
+
 export type EventType = keyof EventPayloads;
 
 interface Envelope {
@@ -181,6 +223,47 @@ export const payloadFileSchemas = {
   }),
   "human.input_requested": z.looseObject({ call_id: z.string(), question: z.string() }),
   "human.input_provided": z.looseObject({ call_id: z.string(), answer: z.string() }),
+  "approval.requested": z.looseObject({
+    approval_id: z.string(),
+    call: z.looseObject({ call_id: z.string(), name: z.string(), input: z.unknown() }),
+    rule_id: z.string(),
+    kind: z.enum(["approval", "review"]),
+    approvers: z.array(z.string()).optional(),
+    reviewer: z.looseObject({ role: z.string(), name: z.string().optional() }).optional(),
+  }),
+  "review.requested": z.looseObject({
+    approval_id: z.string(),
+    package: z.looseObject({
+      approval_id: z.string(),
+      work_id: z.string(),
+      action: z.looseObject({ name: z.string(), tool: z.string(), input: z.unknown() }),
+      facts: z.array(z.string()),
+      sources: z.array(
+        z.looseObject({
+          id: z.string(),
+          locator: z.string().optional(),
+          version: z.string().optional(),
+        }),
+      ),
+      company_rules: z.array(z.looseObject({ id: z.string(), statement: z.string() })),
+      proposal: z.string(),
+      question: z.string(),
+      requested_by: z.string(),
+      requested_at: z.iso.datetime(),
+    }),
+  }),
+  "review.decided": z.looseObject({
+    approval_id: z.string(),
+    decision_id: z.string().optional(),
+  }),
+  "decision.applied": z.looseObject({ call_id: z.string(), decision_id: z.string() }),
+  "approval.decided": z.looseObject({
+    approval_id: z.string(),
+    decision: z.enum(["approve", "reject", "modify"]),
+    by: z.string(),
+    comment: z.string().optional(),
+    modified_input: z.unknown().optional(),
+  }),
   "human.message": z.looseObject({ text: z.string() }),
   "prompt.expanded": z.looseObject({ name: z.string(), source: z.string(), text: z.string() }),
   "usage.recorded": z.discriminatedUnion("kind", [
@@ -455,6 +538,95 @@ const codecs: { [T in EventType]?: Codec<T> } = {
     toFile: (p) => ({ call_id: p.callId, answer: p.answer }),
     fromFile: (p) => ({ callId: p.call_id, answer: p.answer }),
   },
+  "approval.requested": {
+    toFile: (p) => ({
+      approval_id: p.approvalId,
+      call: { call_id: p.call.callId, name: p.call.name, input: p.call.input },
+      rule_id: p.ruleId,
+      kind: p.kind,
+      ...(p.approvers && { approvers: p.approvers }),
+      ...(p.reviewer && { reviewer: p.reviewer }),
+    }),
+    fromFile: (p) => ({
+      approvalId: p.approval_id,
+      call: { callId: p.call.call_id, name: p.call.name, input: p.call.input },
+      ruleId: p.rule_id,
+      kind: p.kind,
+      ...(p.approvers && { approvers: p.approvers }),
+      ...(p.reviewer && {
+        reviewer: {
+          role: p.reviewer.role,
+          ...(p.reviewer.name !== undefined && { name: p.reviewer.name }),
+        },
+      }),
+    }),
+  },
+  "review.requested": {
+    toFile: (p) => ({
+      approval_id: p.approvalId,
+      package: {
+        approval_id: p.package.approvalId,
+        work_id: p.package.workId,
+        action: p.package.action,
+        facts: p.package.facts,
+        sources: p.package.sources,
+        company_rules: p.package.companyRules,
+        proposal: p.package.proposal,
+        question: p.package.question,
+        requested_by: p.package.requestedBy,
+        requested_at: p.package.requestedAt,
+      },
+    }),
+    fromFile: (p) => ({
+      approvalId: p.approval_id,
+      package: {
+        approvalId: p.package.approval_id,
+        workId: p.package.work_id,
+        action: p.package.action,
+        facts: p.package.facts,
+        sources: p.package.sources.map((source) => ({
+          id: source.id,
+          ...(source.locator !== undefined && { locator: source.locator }),
+          ...(source.version !== undefined && { version: source.version }),
+        })),
+        companyRules: p.package.company_rules,
+        proposal: p.package.proposal,
+        question: p.package.question,
+        requestedBy: p.package.requested_by,
+        requestedAt: p.package.requested_at,
+      },
+    }),
+  },
+  "review.decided": {
+    toFile: (p) => ({
+      approval_id: p.approvalId,
+      ...(p.decisionId !== undefined && { decision_id: p.decisionId }),
+    }),
+    fromFile: (p) => ({
+      approvalId: p.approval_id,
+      ...(p.decision_id !== undefined && { decisionId: p.decision_id }),
+    }),
+  },
+  "decision.applied": {
+    toFile: (p) => ({ call_id: p.callId, decision_id: p.decisionId }),
+    fromFile: (p) => ({ callId: p.call_id, decisionId: p.decision_id }),
+  },
+  "approval.decided": {
+    toFile: (p) => ({
+      approval_id: p.approvalId,
+      decision: p.decision,
+      by: p.by,
+      ...(p.comment !== undefined && { comment: p.comment }),
+      ...(p.modifiedInput !== undefined && { modified_input: p.modifiedInput }),
+    }),
+    fromFile: (p) => ({
+      approvalId: p.approval_id,
+      decision: p.decision,
+      by: p.by,
+      ...(p.comment !== undefined && { comment: p.comment }),
+      ...(p.modified_input !== undefined && { modifiedInput: p.modified_input }),
+    }),
+  },
   "usage.recorded": {
     toFile: (p) =>
       p.kind === "tool_execution"

package/src/work/history.ts

@@ -44,6 +44,28 @@ export function pendingQuestions(events: readonly AnyEvent[]): PendingQuestion[]
     .map((e) => ({ callId: e.payload.callId, question: e.payload.question }));
 }
 
+export interface PendingApproval {
+  approvalId: string;
+  call: { callId: string; name: string; input: unknown };
+  ruleId: string;
+  kind: "approval" | "review";
+  approvers?: string[];
+  reviewer?: { role: string; name?: string };
+}
+
+/** The approvals of the work that have no decision yet, oldest first. */
+export function pendingApprovals(events: readonly AnyEvent[]): PendingApproval[] {
+  const decided = new Set(
+    events
+      .filter((e): e is Event<"approval.decided"> => e.type === "approval.decided")
+      .map((e) => e.payload.approvalId),
+  );
+  return events
+    .filter((e): e is Event<"approval.requested"> => e.type === "approval.requested")
+    .filter((e) => !decided.has(e.payload.approvalId))
+    .map((e) => ({ ...e.payload }));
+}
+
 export interface HistoryCall {
   callId: string;
   name: string;
@@ -59,6 +81,8 @@ export interface WorkHistory {
   /** Calls that were started but have no result: the work stopped while they ran. */
   unfinished: HistoryCall[];
   pending: PendingQuestion[];
+  /** Calls held for approval that nobody has decided on yet. */
+  approvals: PendingApproval[];
   toolCalls: number;
   /** Model calls recorded on the work, for a client that counts them against a limit. */
   modelCalls: number;
@@ -90,6 +114,7 @@ export function workHistory(events: readonly AnyEvent[]): WorkHistory {
     calls,
     unfinished: calls.filter((c) => c.isError === undefined && c.rejected === undefined),
     pending: pendingQuestions(events),
+    approvals: pendingApprovals(events),
     toolCalls: countToolCalls(events),
     modelCalls: events.filter((e) => e.type === "model.requested").length,
   };

package/src/work/projection.ts

@@ -35,12 +35,24 @@ export function buildProjection(input: ProjectionInput): Projection {
     first?.type === "work.created" ? (first as Event<"work.created">).payload.agentName : undefined;
   const system = [
     config.profession.instructions.trim(),
-    `この会社は ${config.company.name}。`,
-    `依頼する人は ${config.principal.name}(${config.principal.id})。あなたはこの人の代理として働き、この人と話す。あなた自身は ${config.principal.name} ではなく、この会社で働く社員エージェントで、名乗るならそう名乗る。`,
-    ...(agentName
-      ? [`あなたの名前は ${agentName}。名乗るときはこの名前と、社員エージェントであることを言う。`]
-      : []),
-    "件数、合計、検索の結果は Tool が返した値をそのまま使い、自分で数えたり合計したりしない。各ターンの最後に Runtime が「残り model 呼び出し N 回、Tool 呼び出し M 回」という 1 行を user message として追加する。これは残量の通知で、返事は要らない。依頼が終わったら、何をしたかを要約して終える。",
+    [
+      "# 立場",
+      `この会社は ${config.company.name}。依頼する人は ${config.principal.name}(${config.principal.id})。あなたはこの人の代理として働き、この人と話す。あなた自身は ${config.principal.name} ではなく、この会社で働く社員エージェント。`,
+      ...(agentName
+        ? [
+            `あなたの名前は ${agentName}。名乗るときはこの名前と、社員エージェントであることを言う。`,
+          ]
+        : []),
+      "",
+      "# 数字と事実",
+      "件数、合計、検索の結果は Tool が返した値をそのまま使う。自分で数え直したり足し直したりしない。日付と時刻は context を呼んで確かめ、推測しない。",
+      "",
+      "# 残り回数",
+      "各ターンの最後に「残り model 呼び出し N 回、Tool 呼び出し M 回」という 1 行が user message として届く。残量の通知なので、返事は要らない。",
+      "",
+      "# 終わり方",
+      "依頼が終わったら、何をしたかと結果の数字を書いて終える。",
+    ].join("\n"),
   ].join("\n\n");
 
   const messages: ModelMessage[] = [];