refactor(agent-core-v2): drop the @moonshot-ai/protocol dependency (#1745)

Author: kermanx

packages/agent-core-v2/package.json

@@ -62,7 +62,6 @@
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@moonshot-ai/kimi-code-oauth": "workspace:^",
     "@moonshot-ai/minidb": "workspace:^",
-    "@moonshot-ai/protocol": "workspace:^",
     "@mozilla/readability": "^0.6.0",
     "ajv": "^8.18.0",
     "ajv-formats": "^3.0.1",

packages/agent-core-v2/scripts/check-domain-layers.mjs

@@ -304,6 +304,11 @@ const ALLOWED_EXCEPTIONS = new Set([
   'auth>tool',
   'auth>toolRegistry',
   'permissionGate>approval',
+  // `permissionRules` (L3) persists the approval broker's `ApprovalResponse`
+  // (Session, L7) verbatim in its wire-logged `PermissionApprovalResultRecord`
+  // — a real cross-scope dependency, surfaced here rather than hidden behind a
+  // re-declared copy of the shape.
+  'permissionRules>approval',
   'userTool>interaction',
   'permissionPolicy>plan',
   'permissionPolicy>swarm',

packages/agent-core-v2/src/_base/errors/codes.ts

@@ -6,13 +6,12 @@
  * codes, the registry (`registerErrorDomain` / `errorInfo` / `isErrorCode`) the
  * serializer reads, and the domain-independent core codes (`internal`,
  * `not_implemented`). Domain-owned codes live next to their owning domain and
- * are aggregated into the public `ErrorCodes` const by `#/errors`.
+ * are aggregated into the public `ErrorCodes` const by `#/errors`, which also
+ * derives the `ErrorCode` union type from that aggregate — so each domain's
+ * `errors.ts` is the single source of truth and there is no central
+ * hand-maintained list to keep in sync.
  */
 
-import type { KimiErrorCode } from '@moonshot-ai/protocol';
-
-export type ErrorCode = KimiErrorCode;
-
 export interface ErrorInfo {
   readonly title: string;
   readonly retryable: boolean;
@@ -21,18 +20,25 @@ export interface ErrorInfo {
 }
 
 export interface ErrorDomain {
-  readonly codes: { readonly [name: string]: ErrorCode };
-  readonly retryable?: ReadonlyArray<ErrorCode>;
+  readonly codes: { readonly [name: string]: string };
+  readonly retryable?: ReadonlyArray<string>;
   readonly info?: { readonly [code: string]: ErrorInfo };
 }
 
-const registeredCodes = new Set<ErrorCode>();
-const retryableCodes = new Set<ErrorCode>();
+// Maps each registered code to the `codes` object that contributed it: a
+// domain re-registering itself stays idempotent, while two different domains
+// claiming the same code fail loudly at registration time.
+const registeredCodes = new Map<string, object>();
+const retryableCodes = new Set<string>();
 const infoOverrides: { [code: string]: ErrorInfo } = {};
 
 export function registerErrorDomain(domain: ErrorDomain): void {
   for (const code of Object.values(domain.codes)) {
-    registeredCodes.add(code);
+    const owner = registeredCodes.get(code);
+    if (owner !== undefined && owner !== domain.codes) {
+      throw new Error(`error code '${code}' is registered by two different domains`);
+    }
+    registeredCodes.set(code, domain.codes);
   }
   for (const code of domain.retryable ?? []) {
     retryableCodes.add(code);
@@ -42,11 +48,11 @@ export function registerErrorDomain(domain: ErrorDomain): void {
   }
 }
 
-export function isErrorCode(code: unknown): code is ErrorCode {
-  return typeof code === 'string' && registeredCodes.has(code as ErrorCode);
+export function isErrorCode(code: unknown): code is string {
+  return typeof code === 'string' && registeredCodes.has(code);
 }
 
-export function errorInfo(code: ErrorCode): ErrorInfo {
+export function errorInfo(code: string): ErrorInfo {
   const override = infoOverrides[code];
   if (override !== undefined) return override;
   return {
@@ -60,6 +66,7 @@ export const CoreErrors = {
   codes: {
     INTERNAL: 'internal',
     NOT_IMPLEMENTED: 'not_implemented',
+    VALIDATION_FAILED: 'validation.failed',
   },
   info: {
     internal: {

packages/agent-core-v2/src/_base/errors/errors.ts

@@ -4,7 +4,7 @@
  */
 
 import { CoreErrors } from './codes';
-import type { ErrorCode } from './codes';
+import type { ErrorCode } from '#/errors';
 
 export class ExpectedError extends Error {
   readonly isExpected = true;

packages/agent-core-v2/src/_base/errors/serialize.ts

@@ -9,7 +9,7 @@
  */
 
 import { CoreErrors, errorInfo, isErrorCode } from './codes';
-import type { ErrorCode } from './codes';
+import type { ErrorCode } from '#/errors';
 import { Error2 } from './errors';
 
 export interface ErrorPayload {

packages/agent-core-v2/src/_base/utils/isoDateTime.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+
+const ISO_8601_REGEX =
+  /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?(?:Z|[+-]\d{2}(?::?\d{2})?)$/;
+
+/**
+ * Wire-schema primitive for ISO 8601 datetime strings: validates the shape and
+ * normalizes to `Date#toISOString()` output. Shared by the edge DTO schemas
+ * (`sessionFs`, `file`, `terminal`, `auth`, …) that expose timestamps.
+ */
+export const isoDateTimeSchema = z
+  .string()
+  .refine((value) => ISO_8601_REGEX.test(value), {
+    message: 'must be an ISO 8601 datetime string',
+  })
+  .transform((value, ctx) => {
+    const ms = Date.parse(value);
+    if (Number.isNaN(ms)) {
+      ctx.addIssue({
+        code: 'custom',
+        message: 'invalid ISO 8601 datetime',
+      });
+      return z.NEVER;
+    }
+    return new Date(ms).toISOString();
+  });

packages/agent-core-v2/src/activity/activity.ts

@@ -18,7 +18,8 @@
 import { createDecorator, type ServiceIdentifier } from '#/_base/di/instantiation';
 import type { IDisposable } from '#/_base/di/lifecycle';
 import type { PromptOrigin } from '#/agent/contextMemory/types';
-import type { TurnEndReason } from '@moonshot-ai/protocol';
+
+export type TurnEndReason = 'completed' | 'cancelled' | 'failed' | 'blocked';
 
 export type AgentLifecycleState = 'initializing' | 'ready' | 'disposing' | 'disposed';
 

packages/agent-core-v2/src/agent/contextMemory/messageProjection.ts

@@ -15,7 +15,7 @@
  * so REST consumers can still render the media after reload/resume.
  */
 
-import type { Message, MessageContent, MessageRole, ToolUseContent } from '@moonshot-ai/protocol';
+import type { Message, MessageContent, MessageRole, ToolUseContent } from './wireMessage';
 
 import type { ContextMessage } from './types';
 

packages/agent-core-v2/src/agent/contextMemory/types.ts

@@ -1,7 +1,6 @@
 import type { ContentPart, Message } from '#/app/llmProtocol/message';
 
 import type { AgentTaskStatus } from '#/agent/task/task';
-import type { CronJobOrigin, CronMissedOrigin, ShellCommandOrigin } from '@moonshot-ai/protocol';
 
 export type SkillSource = 'project' | 'user' | 'extra' | 'builtin';
 
@@ -36,6 +35,14 @@ export interface InjectionOrigin {
   readonly variant: string;
 }
 
+export interface ShellCommandOrigin {
+  readonly kind: 'shell_command';
+  readonly phase: 'input' | 'output';
+  /** Only present on `phase: 'output'` — whether the command failed, so replay
+   *  can colour stderr red only for actual failures (not warnings). */
+  readonly isError?: boolean;
+}
+
 export interface CompactionSummaryOrigin {
   readonly kind: 'compaction_summary';
 }
@@ -52,6 +59,20 @@ export interface TaskOrigin {
   readonly notificationId: string;
 }
 
+export interface CronJobOrigin {
+  readonly kind: 'cron_job';
+  readonly jobId: string;
+  readonly cron: string;
+  readonly recurring: boolean;
+  readonly coalescedCount: number;
+  readonly stale: boolean;
+}
+
+export interface CronMissedOrigin {
+  readonly kind: 'cron_missed';
+  readonly count: number;
+}
+
 export interface HookResultOrigin {
   readonly kind: 'hook_result';
   readonly event: string;

packages/agent-core-v2/src/agent/contextMemory/wireMessage.ts

@@ -0,0 +1,100 @@
+/**
+ * The wire `Message` shape — the legacy REST/streaming message format served
+ * on the `messages`, `snapshot`, and `sessions` (`:undo`) edge surfaces.
+ * Defined next to `messageProjection.ts`, which projects `ContextMessage`
+ * into this shape; consumed by the `messageLegacy` edge adapter and the
+ * transports.
+ */
+
+import { z } from 'zod';
+
+import { isoDateTimeSchema } from '#/_base/utils/isoDateTime';
+
+export const messageRoleSchema = z.enum(['user', 'assistant', 'tool', 'system']);
+export type MessageRole = z.infer<typeof messageRoleSchema>;
+
+export const textContentSchema = z.object({
+  type: z.literal('text'),
+  text: z.string(),
+});
+export type TextContent = z.infer<typeof textContentSchema>;
+
+export const toolUseContentSchema = z.object({
+  type: z.literal('tool_use'),
+  tool_call_id: z.string().min(1),
+  tool_name: z.string().min(1),
+  input: z.unknown(),
+});
+export type ToolUseContent = z.infer<typeof toolUseContentSchema>;
+
+export const toolResultContentSchema = z.object({
+  type: z.literal('tool_result'),
+  tool_call_id: z.string().min(1),
+  output: z.unknown(),
+  is_error: z.boolean().optional(),
+});
+export type ToolResultContent = z.infer<typeof toolResultContentSchema>;
+
+export const imageSourceSchema = z.discriminatedUnion('kind', [
+  z.object({ kind: z.literal('url'), url: z.string().min(1) }),
+  z.object({
+    kind: z.literal('base64'),
+    media_type: z.string().min(1),
+    data: z.string().min(1),
+  }),
+  z.object({ kind: z.literal('file'), file_id: z.string().min(1) }),
+]);
+export type ImageSource = z.infer<typeof imageSourceSchema>;
+
+export const imageContentSchema = z.object({
+  type: z.literal('image'),
+  source: imageSourceSchema,
+});
+export type ImageContent = z.infer<typeof imageContentSchema>;
+
+// Video uses the same source shape as image (url / base64 / uploaded file id).
+export const videoContentSchema = z.object({
+  type: z.literal('video'),
+  source: imageSourceSchema,
+});
+export type VideoContent = z.infer<typeof videoContentSchema>;
+
+export const fileContentSchema = z.object({
+  type: z.literal('file'),
+  file_id: z.string().min(1),
+  name: z.string(),
+  media_type: z.string().min(1),
+  size: z.number().int().nonnegative(),
+});
+export type FileContent = z.infer<typeof fileContentSchema>;
+
+export const thinkingContentSchema = z.object({
+  type: z.literal('thinking'),
+  thinking: z.string(),
+  signature: z.string().optional(),
+});
+export type ThinkingContent = z.infer<typeof thinkingContentSchema>;
+
+export const messageContentSchema = z.discriminatedUnion('type', [
+  textContentSchema,
+  toolUseContentSchema,
+  toolResultContentSchema,
+  imageContentSchema,
+  videoContentSchema,
+  fileContentSchema,
+  thinkingContentSchema,
+]);
+export type MessageContent = z.infer<typeof messageContentSchema>;
+
+export const messageSchema = z.object({
+  id: z.string().min(1),
+  session_id: z.string().min(1),
+  role: messageRoleSchema,
+  content: z.array(messageContentSchema),
+  created_at: isoDateTimeSchema,
+  prompt_id: z.string().min(1).optional(),
+  parent_message_id: z.string().min(1).optional(),
+  metadata: z.record(z.string(), z.unknown()).optional(),
+});
+
+export type Message = z.infer<typeof messageSchema>;