saeeol 1.2.0 → 1.2.2

package/src/session/message/message.ts

@@ -0,0 +1,192 @@
+import { Schema } from "effect"
+import { SessionID } from "../core/schema"
+import { ModelID, ProviderID } from "../../provider/schema"
+import { zod } from "@/util/effect-zod"
+import { NonNegativeInt, withStatics } from "@/util/schema"
+import { namedSchemaError } from "@/util/named-schema-error"
+
+export const OutputLengthError = namedSchemaError("MessageOutputLengthError", {})
+export const AuthError = namedSchemaError("ProviderAuthError", {
+  providerID: Schema.String,
+  message: Schema.String,
+})
+
+const AuthErrorEffect = Schema.Struct({
+  name: Schema.Literal("ProviderAuthError"),
+  data: Schema.Struct({
+    providerID: Schema.String,
+    message: Schema.String,
+  }),
+})
+
+const OutputLengthErrorEffect = Schema.Struct({
+  name: Schema.Literal("MessageOutputLengthError"),
+  data: Schema.Struct({}),
+})
+
+const UnknownErrorEffect = Schema.Struct({
+  name: Schema.Literal("UnknownError"),
+  data: Schema.Struct({
+    message: Schema.String,
+  }),
+})
+
+export const ToolCall = Schema.Struct({
+  state: Schema.Literal("call"),
+  step: Schema.optional(NonNegativeInt),
+  toolCallId: Schema.String,
+  toolName: Schema.String,
+  args: Schema.Unknown,
+})
+  .annotate({ identifier: "ToolCall" })
+  .pipe(withStatics((s) => ({ zod: zod(s) })))
+export type ToolCall = Schema.Schema.Type<typeof ToolCall>
+
+export const ToolPartialCall = Schema.Struct({
+  state: Schema.Literal("partial-call"),
+  step: Schema.optional(NonNegativeInt),
+  toolCallId: Schema.String,
+  toolName: Schema.String,
+  args: Schema.Unknown,
+})
+  .annotate({ identifier: "ToolPartialCall" })
+  .pipe(withStatics((s) => ({ zod: zod(s) })))
+export type ToolPartialCall = Schema.Schema.Type<typeof ToolPartialCall>
+
+export const ToolResult = Schema.Struct({
+  state: Schema.Literal("result"),
+  step: Schema.optional(NonNegativeInt),
+  toolCallId: Schema.String,
+  toolName: Schema.String,
+  args: Schema.Unknown,
+  result: Schema.String,
+})
+  .annotate({ identifier: "ToolResult" })
+  .pipe(withStatics((s) => ({ zod: zod(s) })))
+export type ToolResult = Schema.Schema.Type<typeof ToolResult>
+
+export const ToolInvocation = Schema.Union([ToolCall, ToolPartialCall, ToolResult])
+  .annotate({ identifier: "ToolInvocation", discriminator: "state" })
+  .pipe(withStatics((s) => ({ zod: zod(s) })))
+export type ToolInvocation = Schema.Schema.Type<typeof ToolInvocation>
+
+export const TextPart = Schema.Struct({
+  type: Schema.Literal("text"),
+  text: Schema.String,
+})
+  .annotate({ identifier: "TextPart" })
+  .pipe(withStatics((s) => ({ zod: zod(s) })))
+export type TextPart = Schema.Schema.Type<typeof TextPart>
+
+export const ReasoningPart = Schema.Struct({
+  type: Schema.Literal("reasoning"),
+  text: Schema.String,
+  providerMetadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+})
+  .annotate({ identifier: "ReasoningPart" })
+  .pipe(withStatics((s) => ({ zod: zod(s) })))
+export type ReasoningPart = Schema.Schema.Type<typeof ReasoningPart>
+
+export const ToolInvocationPart = Schema.Struct({
+  type: Schema.Literal("tool-invocation"),
+  toolInvocation: ToolInvocation,
+})
+  .annotate({ identifier: "ToolInvocationPart" })
+  .pipe(withStatics((s) => ({ zod: zod(s) })))
+export type ToolInvocationPart = Schema.Schema.Type<typeof ToolInvocationPart>
+
+export const SourceUrlPart = Schema.Struct({
+  type: Schema.Literal("source-url"),
+  sourceId: Schema.String,
+  url: Schema.String,
+  title: Schema.optional(Schema.String),
+  providerMetadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+})
+  .annotate({ identifier: "SourceUrlPart" })
+  .pipe(withStatics((s) => ({ zod: zod(s) })))
+export type SourceUrlPart = Schema.Schema.Type<typeof SourceUrlPart>
+
+export const FilePart = Schema.Struct({
+  type: Schema.Literal("file"),
+  mediaType: Schema.String,
+  filename: Schema.optional(Schema.String),
+  url: Schema.String,
+})
+  .annotate({ identifier: "FilePart" })
+  .pipe(withStatics((s) => ({ zod: zod(s) })))
+export type FilePart = Schema.Schema.Type<typeof FilePart>
+
+export const StepStartPart = Schema.Struct({
+  type: Schema.Literal("step-start"),
+})
+  .annotate({ identifier: "StepStartPart" })
+  .pipe(withStatics((s) => ({ zod: zod(s) })))
+export type StepStartPart = Schema.Schema.Type<typeof StepStartPart>
+
+export const MessagePart = Schema.Union([
+  TextPart,
+  ReasoningPart,
+  ToolInvocationPart,
+  SourceUrlPart,
+  FilePart,
+  StepStartPart,
+])
+  .annotate({ identifier: "MessagePart", discriminator: "type" })
+  .pipe(withStatics((s) => ({ zod: zod(s) })))
+export type MessagePart = Schema.Schema.Type<typeof MessagePart>
+
+export const Info = Schema.Struct({
+  id: Schema.String,
+  role: Schema.Literals(["user", "assistant"]),
+  parts: Schema.Array(MessagePart),
+  metadata: Schema.Struct({
+    time: Schema.Struct({
+      created: NonNegativeInt,
+      completed: Schema.optional(NonNegativeInt),
+    }),
+    error: Schema.optional(Schema.Union([AuthErrorEffect, UnknownErrorEffect, OutputLengthErrorEffect])),
+    sessionID: SessionID,
+    tool: Schema.Record(
+      Schema.String,
+      Schema.StructWithRest(
+        Schema.Struct({
+          title: Schema.String,
+          snapshot: Schema.optional(Schema.String),
+          time: Schema.Struct({
+            start: NonNegativeInt,
+            end: NonNegativeInt,
+          }),
+        }),
+        [Schema.Record(Schema.String, Schema.Unknown)],
+      ),
+    ),
+    assistant: Schema.optional(
+      Schema.Struct({
+        system: Schema.Array(Schema.String),
+        modelID: ModelID,
+        providerID: ProviderID,
+        path: Schema.Struct({
+          cwd: Schema.String,
+          root: Schema.String,
+        }),
+        cost: Schema.Finite,
+        summary: Schema.optional(Schema.Boolean),
+        tokens: Schema.Struct({
+          input: NonNegativeInt,
+          output: NonNegativeInt,
+          reasoning: NonNegativeInt,
+          cache: Schema.Struct({
+            read: NonNegativeInt,
+            write: NonNegativeInt,
+          }),
+        }),
+      }),
+    ),
+    snapshot: Schema.optional(Schema.String),
+  }).annotate({ identifier: "MessageMetadata" }),
+})
+  .annotate({ identifier: "Message" })
+  .pipe(withStatics((s) => ({ zod: zod(s) })))
+export type Info = Schema.Schema.Type<typeof Info>
+
+export * as Message from "./message"

package/src/session/message-errors.ts

@@ -1,83 +1 @@
-/** 에러 타입 + fromError + OutputFormat — message-v2.ts에서 분리 */
-
-import { APICallError, LoadAPIKeyError } from "ai"
-import { NamedError } from "@saeeol/core/util/error"
-import * as ProviderError from "@/provider/error"
-import { SessionNetwork } from "./network"
-import { CodexAuthExpiredError } from "@/saeeol/provider/codex-refresh"
-import { Effect, Schema } from "effect"
-import { zod } from "@/util/effect-zod"
-import { NonNegativeInt } from "@/util/schema"
-import { namedSchemaError } from "@/util/named-schema-error"
-import { errorMessage } from "@/util/error"
-import { ProviderID } from "@/provider/schema"
-import type { Assistant } from "./message-types"
-
-interface FetchDecompressionError extends Error { code: "ZlibError"; errno: number; path: string }
-
-export const OutputLengthError = namedSchemaError("MessageOutputLengthError", {})
-export const AbortedError = namedSchemaError("MessageAbortedError", { message: Schema.String })
-export const StructuredOutputError = namedSchemaError("StructuredOutputError", { message: Schema.String, retries: NonNegativeInt })
-export const AuthError = namedSchemaError("ProviderAuthError", { providerID: Schema.String, message: Schema.String })
-export const APIError = namedSchemaError("APIError", {
-  message: Schema.String, statusCode: Schema.optional(NonNegativeInt), isRetryable: Schema.Boolean,
-  responseHeaders: Schema.optional(Schema.Record(Schema.String, Schema.String)), responseBody: Schema.optional(Schema.String),
-  metadata: Schema.optional(Schema.Record(Schema.String, Schema.String)),
-})
-export type APIError = import("zod").infer<typeof APIError.Schema>
-export const ContextOverflowError = namedSchemaError("ContextOverflowError", { message: Schema.String, responseBody: Schema.optional(Schema.String) })
-
-export class OutputFormatText extends Schema.Class<OutputFormatText>("OutputFormatText")({ type: Schema.Literal("text") }) { static readonly zod = zod(this) }
-export class OutputFormatJsonSchema extends Schema.Class<OutputFormatJsonSchema>("OutputFormatJsonSchema")({
-  type: Schema.Literal("json_schema"), schema: Schema.Record(Schema.String, Schema.Any).annotate({ identifier: "JSONSchema" }),
-  retryCount: NonNegativeInt.pipe(Schema.optional, Schema.withDecodingDefault(Effect.succeed(2))),
-}) { static readonly zod = zod(this) }
-
-const _Format = Schema.Union([OutputFormatText, OutputFormatJsonSchema]).annotate({ discriminator: "type", identifier: "OutputFormat" })
-export { _Format }
-export const Format = Object.assign(_Format, { zod: zod(_Format) })
-export type OutputFormat = Schema.Schema.Type<typeof _Format>
-
-// Assistant error union (Zod)
-import z from "zod"
-const AssistantErrorZod = z.discriminatedUnion("name", [
-  AuthError.Schema, NamedError.Unknown.Schema, OutputLengthError.Schema, AbortedError.Schema,
-  StructuredOutputError.Schema, ContextOverflowError.Schema, APIError.Schema,
-])
-export type AssistantError = z.infer<typeof AssistantErrorZod>
-export { AssistantErrorZod }
-
-// Assistant error union (Effect Schema)
-export const AssistantErrorSchema = Schema.Union([
-  AuthError.EffectSchema,
-  Schema.Struct({ name: Schema.Literal("UnknownError"), data: Schema.Struct({ message: Schema.String }) }).annotate({ identifier: "UnknownError" }),
-  OutputLengthError.EffectSchema, AbortedError.EffectSchema, StructuredOutputError.EffectSchema, ContextOverflowError.EffectSchema, APIError.EffectSchema,
-]).annotate({ discriminator: "name" })
-
-export function fromError(e: unknown, ctx: { providerID: ProviderID; aborted?: boolean }): NonNullable<Assistant["error"]> {
-  switch (true) {
-    case e instanceof DOMException && e.name === "AbortError": return new AbortedError({ message: e.message }, { cause: e }).toObject()
-    case OutputLengthError.isInstance(e): return e
-    case LoadAPIKeyError.isInstance(e): return new AuthError({ providerID: ctx.providerID, message: e.message }, { cause: e }).toObject()
-    case e instanceof CodexAuthExpiredError: return new AuthError({ providerID: "openai", message: e.message }, { cause: e }).toObject()
-    case SessionNetwork.disconnected(e):
-      return new APIError({ message: SessionNetwork.message(e), isRetryable: true, metadata: { code: (e as import("bun").SystemError).code ?? "", syscall: (e as import("bun").SystemError).syscall ?? "", message: (e as import("bun").SystemError).message ?? "" } }, { cause: e }).toObject()
-    case e instanceof Error && (e as FetchDecompressionError).code === "ZlibError":
-      if (ctx.aborted) return new AbortedError({ message: e.message }, { cause: e }).toObject()
-      return new APIError({ message: "Response decompression failed", isRetryable: true, metadata: { code: (e as FetchDecompressionError).code, message: e.message } }, { cause: e }).toObject()
-    case APICallError.isInstance(e):
-      const parsed = ProviderError.parseAPICallError({ providerID: ctx.providerID, error: e })
-      if (parsed.type === "context_overflow") return new ContextOverflowError({ message: parsed.message, responseBody: parsed.responseBody }, { cause: e }).toObject()
-      return new APIError({ message: parsed.message, statusCode: parsed.statusCode, isRetryable: parsed.isRetryable, responseHeaders: parsed.responseHeaders, responseBody: parsed.responseBody, metadata: parsed.metadata }, { cause: e }).toObject()
-    case e instanceof Error: return new NamedError.Unknown({ message: errorMessage(e) }, { cause: e }).toObject()
-    default:
-      try {
-        const parsed = ProviderError.parseStreamError(e)
-        if (parsed) {
-          if (parsed.type === "context_overflow") return new ContextOverflowError({ message: parsed.message, responseBody: parsed.responseBody }, { cause: e }).toObject()
-          return new APIError({ message: parsed.message, isRetryable: parsed.isRetryable, responseBody: parsed.responseBody }, { cause: e }).toObject()
-        }
-      } catch {}
-      return new NamedError.Unknown({ message: JSON.stringify(e) }, { cause: e }).toObject()
-  }
-}
+export * from "./message/message-errors"

package/src/session/message-parts.ts

@@ -1,89 +1 @@
-/** Part 스키마 + ToolState + Input 스키마 — message-v2.ts에서 분리 */
-
-import { SessionID, MessageID, PartID } from "./schema"
-import { LSP } from "@/lsp/lsp"
-import { Snapshot } from "@/snapshot"
-import { Effect, Schema, Types } from "effect"
-import { zod } from "@/util/effect-zod"
-import { NonNegativeInt, withStatics } from "@/util/schema"
-import { APIError } from "./message-errors"
-import { ModelID, ProviderID } from "@/provider/schema"
-import z from "zod"
-
-const partBase = { id: PartID, sessionID: SessionID, messageID: MessageID }
-
-export const SnapshotPart = Schema.Struct({ ...partBase, type: Schema.Literal("snapshot"), snapshot: Schema.String }).annotate({ identifier: "SnapshotPart" }).pipe(withStatics((s) => ({ zod: zod(s) })))
-export type SnapshotPart = Types.DeepMutable<Schema.Schema.Type<typeof SnapshotPart>>
-export const PatchPart = Schema.Struct({ ...partBase, type: Schema.Literal("patch"), hash: Schema.String, files: Schema.Array(Schema.String) }).annotate({ identifier: "PatchPart" }).pipe(withStatics((s) => ({ zod: zod(s) })))
-export type PatchPart = Types.DeepMutable<Schema.Schema.Type<typeof PatchPart>>
-export const TextPart = Schema.Struct({
-  ...partBase, type: Schema.Literal("text"), text: Schema.String, synthetic: Schema.optional(Schema.Boolean), ignored: Schema.optional(Schema.Boolean),
-  time: Schema.optional(Schema.Struct({ start: NonNegativeInt, end: Schema.optional(NonNegativeInt) })), metadata: Schema.optional(Schema.Record(Schema.String, Schema.Any)),
-}).annotate({ identifier: "TextPart" }).pipe(withStatics((s) => ({ zod: zod(s) })))
-export type TextPart = Types.DeepMutable<Schema.Schema.Type<typeof TextPart>>
-export const ReasoningPart = Schema.Struct({
-  ...partBase, type: Schema.Literal("reasoning"), text: Schema.String, metadata: Schema.optional(Schema.Record(Schema.String, Schema.Any)),
-  time: Schema.Struct({ start: NonNegativeInt, end: Schema.optional(NonNegativeInt) }),
-}).annotate({ identifier: "ReasoningPart" }).pipe(withStatics((s) => ({ zod: zod(s) })))
-export type ReasoningPart = Types.DeepMutable<Schema.Schema.Type<typeof ReasoningPart>>
-
-const filePartSourceBase = { text: Schema.Struct({ value: Schema.String, start: NonNegativeInt, end: NonNegativeInt }).annotate({ identifier: "FilePartSourceText" }) }
-export const FileSource = Schema.Struct({ ...filePartSourceBase, type: Schema.Literal("file"), path: Schema.String }).annotate({ identifier: "FileSource" }).pipe(withStatics((s) => ({ zod: zod(s) })))
-export const SymbolSource = Schema.Struct({ ...filePartSourceBase, type: Schema.Literal("symbol"), path: Schema.String, range: LSP.Range, name: Schema.String, kind: NonNegativeInt }).annotate({ identifier: "SymbolSource" }).pipe(withStatics((s) => ({ zod: zod(s) })))
-export const ResourceSource = Schema.Struct({ ...filePartSourceBase, type: Schema.Literal("resource"), clientName: Schema.String, uri: Schema.String }).annotate({ identifier: "ResourceSource" }).pipe(withStatics((s) => ({ zod: zod(s) })))
-
-const _FilePartSource = Schema.Union([FileSource, SymbolSource, ResourceSource]).annotate({ discriminator: "type", identifier: "FilePartSource" })
-export const FilePartSource = Object.assign(_FilePartSource, { zod: zod(_FilePartSource) })
-
-export const FilePart = Schema.Struct({ ...partBase, type: Schema.Literal("file"), mime: Schema.String, filename: Schema.optional(Schema.String), url: Schema.String, source: Schema.optional(_FilePartSource) }).annotate({ identifier: "FilePart" }).pipe(withStatics((s) => ({ zod: zod(s) })))
-export type FilePart = Types.DeepMutable<Schema.Schema.Type<typeof FilePart>>
-export const AgentPart = Schema.Struct({ ...partBase, type: Schema.Literal("agent"), name: Schema.String, source: Schema.optional(Schema.Struct({ value: Schema.String, start: NonNegativeInt, end: NonNegativeInt })) }).annotate({ identifier: "AgentPart" }).pipe(withStatics((s) => ({ zod: zod(s) })))
-export type AgentPart = Types.DeepMutable<Schema.Schema.Type<typeof AgentPart>>
-export const CompactionPart = Schema.Struct({ ...partBase, type: Schema.Literal("compaction"), auto: Schema.Boolean, overflow: Schema.optional(Schema.Boolean), tail_start_id: Schema.optional(MessageID) }).annotate({ identifier: "CompactionPart" }).pipe(withStatics((s) => ({ zod: zod(s) })))
-export type CompactionPart = Types.DeepMutable<Schema.Schema.Type<typeof CompactionPart>>
-export const SubtaskPart = Schema.Struct({ ...partBase, type: Schema.Literal("subtask"), prompt: Schema.String, description: Schema.String, agent: Schema.String, model: Schema.optional(Schema.Struct({ providerID: ProviderID, modelID: ModelID })), command: Schema.optional(Schema.String) }).annotate({ identifier: "SubtaskPart" }).pipe(withStatics((s) => ({ zod: zod(s) })))
-export type SubtaskPart = Types.DeepMutable<Schema.Schema.Type<typeof SubtaskPart>>
-export const RetryPart = Schema.Struct({ ...partBase, type: Schema.Literal("retry"), attempt: NonNegativeInt, error: APIError.EffectSchema, time: Schema.Struct({ created: NonNegativeInt }) }).annotate({ identifier: "RetryPart" }).pipe(withStatics((s) => ({ zod: zod(s) })))
-export type RetryPart = Omit<Types.DeepMutable<Schema.Schema.Type<typeof RetryPart>>, "error"> & { error: APIError }
-export const StepStartPart = Schema.Struct({ ...partBase, type: Schema.Literal("step-start"), snapshot: Schema.optional(Schema.String) }).annotate({ identifier: "StepStartPart" }).pipe(withStatics((s) => ({ zod: zod(s) })))
-export type StepStartPart = Types.DeepMutable<Schema.Schema.Type<typeof StepStartPart>>
-export const StepFinishPart = Schema.Struct({
-  ...partBase, type: Schema.Literal("step-finish"), reason: Schema.String, snapshot: Schema.optional(Schema.String), cost: Schema.Finite,
-  tokens: Schema.Struct({ total: Schema.optional(NonNegativeInt), input: NonNegativeInt, output: NonNegativeInt, reasoning: NonNegativeInt, cache: Schema.Struct({ read: NonNegativeInt, write: NonNegativeInt }) }),
-}).annotate({ identifier: "StepFinishPart" }).pipe(withStatics((s) => ({ zod: zod(s) })))
-export type StepFinishPart = Types.DeepMutable<Schema.Schema.Type<typeof StepFinishPart>>
-
-export const ToolStatePending = Schema.Struct({ status: Schema.Literal("pending"), input: Schema.Record(Schema.String, Schema.Any), raw: Schema.String }).annotate({ identifier: "ToolStatePending" }).pipe(withStatics((s) => ({ zod: zod(s) })))
-export type ToolStatePending = Types.DeepMutable<Schema.Schema.Type<typeof ToolStatePending>>
-export const ToolStateRunning = Schema.Struct({ status: Schema.Literal("running"), input: Schema.Record(Schema.String, Schema.Any), title: Schema.optional(Schema.String), metadata: Schema.optional(Schema.Record(Schema.String, Schema.Any)), time: Schema.Struct({ start: NonNegativeInt }) }).annotate({ identifier: "ToolStateRunning" }).pipe(withStatics((s) => ({ zod: zod(s) })))
-export type ToolStateRunning = Types.DeepMutable<Schema.Schema.Type<typeof ToolStateRunning>>
-export const ToolStateCompleted = Schema.Struct({
-  status: Schema.Literal("completed"), input: Schema.Record(Schema.String, Schema.Any), output: Schema.String, title: Schema.String, metadata: Schema.Record(Schema.String, Schema.Any),
-  time: Schema.Struct({ start: NonNegativeInt, end: NonNegativeInt, compacted: Schema.optional(NonNegativeInt) }), attachments: Schema.optional(Schema.Array(FilePart)),
-}).annotate({ identifier: "ToolStateCompleted" }).pipe(withStatics((s) => ({ zod: zod(s) })))
-export type ToolStateCompleted = Types.DeepMutable<Schema.Schema.Type<typeof ToolStateCompleted>>
-export function truncateToolOutput(text: string, maxChars?: number) { if (!maxChars || text.length <= maxChars) return text; return `${text.slice(0, maxChars)}\n[Tool output truncated for compaction: omitted ${text.length - maxChars} chars]` }
-export const ToolStateError = Schema.Struct({ status: Schema.Literal("error"), input: Schema.Record(Schema.String, Schema.Any), error: Schema.String, metadata: Schema.optional(Schema.Record(Schema.String, Schema.Any)), time: Schema.Struct({ start: NonNegativeInt, end: NonNegativeInt }) }).annotate({ identifier: "ToolStateError" }).pipe(withStatics((s) => ({ zod: zod(s) })))
-export type ToolStateError = Types.DeepMutable<Schema.Schema.Type<typeof ToolStateError>>
-
-const _ToolState = Schema.Union([ToolStatePending, ToolStateRunning, ToolStateCompleted, ToolStateError]).annotate({ discriminator: "status", identifier: "ToolState" })
-export const ToolState = Object.assign(_ToolState, { zod: zod(_ToolState) as unknown as z.ZodType<ToolStatePending | ToolStateRunning | ToolStateCompleted | ToolStateError> })
-export type ToolState = ToolStatePending | ToolStateRunning | ToolStateCompleted | ToolStateError
-export const ToolPart = Schema.Struct({ ...partBase, type: Schema.Literal("tool"), callID: Schema.String, tool: Schema.String, state: _ToolState, metadata: Schema.optional(Schema.Record(Schema.String, Schema.Any)) }).annotate({ identifier: "ToolPart" }).pipe(withStatics((s) => ({ zod: zod(s) })))
-export type ToolPart = Omit<Types.DeepMutable<Schema.Schema.Type<typeof ToolPart>>, "state"> & { state: ToolState }
-
-// Input variants (without ambient IDs)
-export const TextPartInput = Schema.Struct({ id: Schema.optional(PartID), type: Schema.Literal("text"), text: Schema.String, synthetic: Schema.optional(Schema.Boolean), ignored: Schema.optional(Schema.Boolean), time: Schema.optional(Schema.Struct({ start: NonNegativeInt, end: Schema.optional(NonNegativeInt) })), metadata: Schema.optional(Schema.Record(Schema.String, Schema.Any)) }).annotate({ identifier: "TextPartInput" }).pipe(withStatics((s) => ({ zod: zod(s) })))
-export type TextPartInput = Types.DeepMutable<Schema.Schema.Type<typeof TextPartInput>>
-export const FilePartInput = Schema.Struct({ id: Schema.optional(PartID), type: Schema.Literal("file"), mime: Schema.String, filename: Schema.optional(Schema.String), url: Schema.String, source: Schema.optional(_FilePartSource) }).annotate({ identifier: "FilePartInput" }).pipe(withStatics((s) => ({ zod: zod(s) })))
-export type FilePartInput = Types.DeepMutable<Schema.Schema.Type<typeof FilePartInput>>
-export const AgentPartInput = Schema.Struct({ id: Schema.optional(PartID), type: Schema.Literal("agent"), name: Schema.String, source: Schema.optional(Schema.Struct({ value: Schema.String, start: NonNegativeInt, end: NonNegativeInt })) }).annotate({ identifier: "AgentPartInput" }).pipe(withStatics((s) => ({ zod: zod(s) })))
-export type AgentPartInput = Types.DeepMutable<Schema.Schema.Type<typeof AgentPartInput>>
-export const SubtaskPartInput = Schema.Struct({ id: Schema.optional(PartID), type: Schema.Literal("subtask"), prompt: Schema.String, description: Schema.String, agent: Schema.String, model: Schema.optional(Schema.Struct({ providerID: ProviderID, modelID: ModelID })), command: Schema.optional(Schema.String) }).annotate({ identifier: "SubtaskPartInput" }).pipe(withStatics((s) => ({ zod: zod(s) })))
-export type SubtaskPartInput = Types.DeepMutable<Schema.Schema.Type<typeof SubtaskPartInput>>
-
-// Part union
-const _Part = Schema.Union([TextPart, SubtaskPart, ReasoningPart, FilePart, ToolPart, StepStartPart, StepFinishPart, SnapshotPart, PatchPart, AgentPart, RetryPart, CompactionPart]).annotate({ discriminator: "type", identifier: "Part" })
-export const Part = Object.assign(_Part, { zod: zod(_Part) as unknown as z.ZodType<TextPart | SubtaskPart | ReasoningPart | FilePart | ToolPart | StepStartPart | StepFinishPart | SnapshotPart | PatchPart | AgentPart | RetryPart | CompactionPart> })
-export type Part = TextPart | SubtaskPart | ReasoningPart | FilePart | ToolPart | StepStartPart | StepFinishPart | SnapshotPart | PatchPart | AgentPart | RetryPart | CompactionPart
-export { _Part }
+export * from "./message/message-parts"

package/src/session/message-query.ts

@@ -1,107 +1 @@
-import { Effect } from "effect"
-import { and, desc, eq } from "drizzle-orm"
-import { Database } from "@/storage/db"
-import { NotFoundError } from "@/storage/storage"
-import { MessageTable, PartTable, SessionTable } from "./session.sql"
-import { SessionID, MessageID } from "./schema"
-import type { WithParts } from "./message-types"
-import { cursor } from "./message-types"
-import type { Part, CompactionPart } from "./message-parts"
-import { stripPartMetadata, hydrate, older, toInfo } from "./message-transform"
-
-export function page(input: { sessionID: SessionID; limit: number; before?: string }) {
-  const before = input.before ? cursor.decode(input.before) : undefined
-  const where = before
-    ? and(eq(MessageTable.session_id, input.sessionID), older(before))
-    : eq(MessageTable.session_id, input.sessionID)
-  const rows = Database.use((db) =>
-    db
-      .select()
-      .from(MessageTable)
-      .where(where)
-      .orderBy(desc(MessageTable.time_created), desc(MessageTable.id))
-      .limit(input.limit + 1)
-      .all(),
-  )
-  if (rows.length === 0) {
-    const row = Database.use((db) =>
-      db.select({ id: SessionTable.id }).from(SessionTable).where(eq(SessionTable.id, input.sessionID)).get(),
-    )
-    if (!row) throw new NotFoundError({ message: `Session not found: ${input.sessionID}` })
-    return { items: [] as WithParts[], more: false }
-  }
-  const more = rows.length > input.limit
-  const slice = more ? rows.slice(0, input.limit) : rows
-  const items = hydrate(slice)
-  items.reverse()
-  const tail = slice.at(-1)
-  return {
-    items,
-    more,
-    cursor: more && tail ? cursor.encode({ id: tail.id, time: tail.time_created }) : undefined,
-  }
-}
-
-export function* stream(sessionID: SessionID) {
-  const size = 50
-  let before: string | undefined
-  while (true) {
-    const next = page({ sessionID, limit: size, before })
-    if (next.items.length === 0) break
-    for (let i = next.items.length - 1; i >= 0; i--) yield next.items[i]
-    if (!next.more || !next.cursor) break
-    before = next.cursor
-  }
-}
-
-export function parts(message_id: MessageID) {
-  const rows = Database.use((db) =>
-    db.select().from(PartTable).where(eq(PartTable.message_id, message_id)).orderBy(PartTable.id).all(),
-  )
-  return rows.map((row) =>
-    stripPartMetadata({ ...row.data, id: row.id, sessionID: row.session_id, messageID: row.message_id } as Part),
-  )
-}
-
-export function get(input: { sessionID: SessionID; messageID: MessageID }): WithParts {
-  const row = Database.use((db) =>
-    db
-      .select()
-      .from(MessageTable)
-      .where(and(eq(MessageTable.id, input.messageID), eq(MessageTable.session_id, input.sessionID)))
-      .get(),
-  )
-  if (!row) throw new NotFoundError({ message: `Message not found: ${input.messageID}` })
-  return { info: toInfo(row), parts: parts(input.messageID) }
-}
-
-export function filterCompacted(msgs: Iterable<WithParts>) {
-  const result = [] as WithParts[]
-  const completed = new Set<string>()
-  let retain: MessageID | undefined
-  for (const msg of msgs) {
-    result.push(msg)
-    if (retain) {
-      if (msg.info.id === retain) break
-      continue
-    }
-    if (msg.info.role === "user" && completed.has(msg.info.id)) {
-      const part = msg.parts.find((item): item is CompactionPart => item.type === "compaction")
-      if (!part) continue
-      if (!part.tail_start_id) break
-      retain = part.tail_start_id
-      if (msg.info.id === retain) break
-      continue
-    }
-    if (msg.info.role === "user" && completed.has(msg.info.id) && msg.parts.some((part) => part.type === "compaction"))
-      break
-    if (msg.info.role === "assistant" && msg.info.summary && msg.info.finish && !msg.info.error)
-      completed.add(msg.info.parentID)
-  }
-  result.reverse()
-  return result
-}
-
-export const filterCompactedEffect = Effect.fnUntraced(function* (sessionID: SessionID) {
-  return filterCompacted(stream(sessionID))
-})
+export * from "./message/message-query"

package/src/session/message-transform.ts

@@ -1,156 +1 @@
-/** toModelMessages + 메타데이터 스트리핑 + DB 하이드레이션 — message-v2.ts에서 분리 */
-
-import { convertToModelMessages, type UIMessage } from "ai"
-import { Effect } from "effect"
-import { and, desc, eq, inArray, lt, or } from "drizzle-orm"
-import { Database } from "@/storage/db"
-import { MessageTable, PartTable } from "./session.sql"
-import { Snapshot } from "@/snapshot"
-import { iife } from "@/util/iife"
-import { isMedia } from "@/util/media"
-import { MessageID, SessionID } from "./schema"
-import * as EffectLogger from "@saeeol/core/effect/logger"
-import type { Provider } from "@/provider/provider"
-export const SYNTHETIC_ATTACHMENT_PROMPT = "Attached image(s) from tool result:"
-import type { Info, User, WithParts } from "./message-types"
-import type { Part, CompactionPart, ToolState, ToolStateCompleted } from "./message-parts"
-import { truncateToolOutput } from "./message-parts"
-import { AbortedError } from "./message-errors"
-
-export { isMedia }
-
-function stripPatch(value: unknown) {
-  if (typeof value !== "string") return undefined
-  if (Buffer.byteLength(value) > Snapshot.MAX_DIFF_SIZE) return undefined
-  return value
-}
-function withPatch(value: unknown) { const kept = stripPatch(value); return kept ? { patch: kept } : {} }
-
-export function stripPartMetadata(part: Part): Part {
-  if (part.type !== "tool") return part
-  const { state } = part
-  if (state.status !== "completed" && state.status !== "running") return part
-  const meta = state.metadata
-  if (!meta) return part
-  let changed = false
-  let next = meta
-  if (meta.diff !== undefined) { const { diff, ...rest } = next; next = rest; changed = true }
-  if (meta.filediff) { const { before, after, patch, ...rest } = meta.filediff; next = { ...next, filediff: { ...rest, ...withPatch(patch) } }; changed = true }
-  if (Array.isArray(meta.files) && meta.files.length > 0) { next = { ...next, files: meta.files.map((f: Record<string, unknown>) => { const { before, after, patch, diff, ...rest } = f; const kept = stripPatch(patch) ?? stripPatch(diff); return { ...rest, ...(kept ? { patch: kept } : {}) } }) }; changed = true }
-  if (Array.isArray(meta.results) && meta.results.length > 0) { next = { ...next, results: meta.results.map((r: Record<string, unknown>) => { const { diff, ...rest } = r; if (!r.filediff || typeof r.filediff !== "object") return rest; const fd = r.filediff as Record<string, unknown>; const { before, after, patch, ...file } = fd; return { ...rest, filediff: { ...file, ...withPatch(patch) } } }) }; changed = true }
-  if (!changed) return part
-  return { ...part, state: { ...state, metadata: next } } as Part
-}
-
-export function stripMessageMetadata(info: Info): Info {
-  if (info.role !== "user") return info
-  const user = info as User
-  if (!user.summary?.diffs?.length) return info
-  const oversized = (d: Snapshot.FileDiff) => d.patch && Buffer.byteLength(d.patch) > Snapshot.MAX_DIFF_SIZE
-  if (!user.summary.diffs.some(oversized)) return info
-  return { ...user, summary: { ...user.summary, diffs: user.summary.diffs.map((d: Snapshot.FileDiff) => (oversized(d) ? { ...d, patch: "" } : d)) } } as Info
-}
-
-export const toInfo = (row: typeof MessageTable.$inferSelect) => stripMessageMetadata({ ...row.data, id: row.id, sessionID: row.session_id } as Info)
-const toPart = (row: typeof PartTable.$inferSelect) => stripPartMetadata({ ...row.data, id: row.id, sessionID: row.session_id, messageID: row.message_id } as Part)
-
-export const older = (row: { id: MessageID; time: number }) =>
-  or(lt(MessageTable.time_created, row.time), and(eq(MessageTable.time_created, row.time), lt(MessageTable.id, row.id)))
-
-export function hydrate(rows: (typeof MessageTable.$inferSelect)[]) {
-  const ids = rows.map((row) => row.id)
-  const partByMessage = new Map<string, Part[]>()
-  if (ids.length > 0) {
-    const partRows = Database.use((db) => db.select().from(PartTable).where(inArray(PartTable.message_id, ids)).orderBy(PartTable.message_id, PartTable.id).all())
-    for (const row of partRows) { const next = toPart(row); const list = partByMessage.get(row.message_id); if (list) list.push(next); else partByMessage.set(row.message_id, [next]) }
-  }
-  return rows.map((row) => ({ info: toInfo(row), parts: partByMessage.get(row.id) ?? [] }))
-}
-
-function providerMeta(metadata: Record<string, any> | undefined) {
-  if (!metadata) return undefined
-  const { providerExecuted: _, ...rest } = metadata
-  return Object.keys(rest).length > 0 ? rest : undefined
-}
-
-export const toModelMessagesEffect = Effect.fnUntraced(function* (input: WithParts[], model: Provider.Model, options?: { stripMedia?: boolean; toolOutputMaxChars?: number }) {
-  const result: UIMessage[] = []
-  const toolNames = new Set<string>()
-  const supportsMediaInToolResults = (() => {
-    if (model.api.npm === "@ai-sdk/anthropic") return true
-    if (model.api.npm === "@ai-sdk/openai") return true
-    if (model.api.npm === "@ai-sdk/amazon-bedrock") return true
-    if (model.api.npm === "@ai-sdk/google-vertex/anthropic") return true
-    if (model.api.npm === "@ai-sdk/google") { const id = model.api.id.toLowerCase(); return id.includes("gemini-3") && !id.includes("gemini-2") }
-    return false
-  })()
-  const toModelOutput = (opts: { toolCallId: string; input: unknown; output: unknown }) => {
-    const output = opts.output
-    if (typeof output === "string") return { type: "text", value: output }
-    if (typeof output === "object") {
-      const o = output as { text: string; attachments?: Array<{ mime: string; url: string }> }
-      const attachments = (o.attachments ?? []).filter((a) => a.url.startsWith("data:") && a.url.includes(","))
-      return { type: "content", value: [...(o.text ? [{ type: "text", text: o.text }] : []), ...attachments.map((a) => ({ type: "media", mediaType: a.mime, data: iife(() => { const ci = a.url.indexOf(","); return ci === -1 ? a.url : a.url.slice(ci + 1) }) }))] }
-    }
-    return { type: "json", value: output as never }
-  }
-  for (const msg of input) {
-    if (msg.parts.length === 0) continue
-    if (msg.info.role === "user") {
-      const userMessage: UIMessage = { id: msg.info.id, role: "user", parts: [] }
-      result.push(userMessage)
-      for (const part of msg.parts) {
-        if (part.type === "text" && !part.ignored) userMessage.parts.push({ type: "text", text: part.text })
-        if (part.type === "file" && part.mime !== "text/plain" && part.mime !== "application/x-directory") {
-          if (options?.stripMedia && isMedia(part.mime)) userMessage.parts.push({ type: "text", text: `[Attached ${part.mime}: ${part.filename ?? "file"}]` })
-          else userMessage.parts.push({ type: "file", url: part.url, mediaType: part.mime, filename: part.filename })
-        }
-        if (part.type === "compaction") userMessage.parts.push({ type: "text", text: "What did we do so far?" })
-        if (part.type === "subtask") userMessage.parts.push({ type: "text", text: "The following tool was executed by the user" })
-      }
-    }
-    if (msg.info.role === "assistant") {
-      const differentModel = `${model.providerID}/${model.id}` !== `${msg.info.providerID}/${msg.info.modelID}`
-      const media: Array<{ mime: string; url: string }> = []
-      if (msg.info.error && !(AbortedError.isInstance(msg.info.error) && msg.parts.some((p) => p.type !== "step-start" && p.type !== "reasoning"))) continue
-      const assistantMessage: UIMessage = { id: msg.info.id, role: "assistant", parts: [] }
-      for (const part of msg.parts) {
-        if (part.type === "text" && !part.ignored) assistantMessage.parts.push({ type: "text", text: part.text, ...(differentModel ? {} : { providerMetadata: part.metadata }) })
-        if (part.type === "step-start") assistantMessage.parts.push({ type: "step-start" })
-        if (part.type === "tool") {
-          toolNames.add(part.tool)
-          if (part.state.status === "completed") {
-            const outputText = part.state.time.compacted ? "[Old tool result content cleared]" : truncateToolOutput(part.state.output, options?.toolOutputMaxChars)
-            const attachments = part.state.time.compacted || options?.stripMedia ? [] : (part.state.attachments ?? [])
-            const mediaAttachments = attachments.filter((a) => isMedia(a.mime))
-            const nonMediaAttachments = attachments.filter((a) => !isMedia(a.mime))
-            if (!supportsMediaInToolResults && mediaAttachments.length > 0) media.push(...mediaAttachments)
-            const finalAttachments = supportsMediaInToolResults ? attachments : nonMediaAttachments
-            const output = finalAttachments.length > 0 ? { text: outputText, attachments: finalAttachments } : outputText
-            assistantMessage.parts.push({ type: ("tool-" + part.tool) as `tool-${string}`, state: "output-available", toolCallId: part.callID, input: part.state.input, output, ...(part.metadata?.providerExecuted ? { providerExecuted: true } : {}), ...(differentModel ? {} : { callProviderMetadata: providerMeta(part.metadata) }) })
-          }
-          if (part.state.status === "error") {
-            const output = part.state.metadata?.interrupted === true ? part.state.metadata.output : undefined
-            if (typeof output === "string") assistantMessage.parts.push({ type: ("tool-" + part.tool) as `tool-${string}`, state: "output-available", toolCallId: part.callID, input: part.state.input, output, ...(part.metadata?.providerExecuted ? { providerExecuted: true } : {}), ...(differentModel ? {} : { callProviderMetadata: providerMeta(part.metadata) }) })
-            else assistantMessage.parts.push({ type: ("tool-" + part.tool) as `tool-${string}`, state: "output-error", toolCallId: part.callID, input: part.state.input, errorText: part.state.error, ...(part.metadata?.providerExecuted ? { providerExecuted: true } : {}), ...(differentModel ? {} : { callProviderMetadata: providerMeta(part.metadata) }) })
-          }
-          if (part.state.status === "pending" || part.state.status === "running") assistantMessage.parts.push({ type: ("tool-" + part.tool) as `tool-${string}`, state: "output-error", toolCallId: part.callID, input: part.state.input, errorText: "[Tool execution was interrupted]", ...(part.metadata?.providerExecuted ? { providerExecuted: true } : {}), ...(differentModel ? {} : { callProviderMetadata: providerMeta(part.metadata) }) })
-        }
-        if (part.type === "reasoning") {
-          if (differentModel) { if (part.text.trim().length > 0) assistantMessage.parts.push({ type: "text", text: part.text }); continue }
-          assistantMessage.parts.push({ type: "reasoning", text: part.text, providerMetadata: part.metadata })
-        }
-      }
-      if (assistantMessage.parts.length > 0) {
-        result.push(assistantMessage)
-        if (media.length > 0) result.push({ id: MessageID.ascending(), role: "user", parts: [{ type: "text" as const, text: SYNTHETIC_ATTACHMENT_PROMPT }, ...media.map((a) => ({ type: "file" as const, url: a.url, mediaType: a.mime }))] })
-      }
-    }
-  }
-  const tools = Object.fromEntries(Array.from(toolNames).map((n) => [n, { toModelOutput }]))
-  return yield* Effect.promise(() => convertToModelMessages(result.filter((m) => m.parts.some((p) => p.type !== "step-start")), { tools } as any))
-})
-
-export function toModelMessages(input: WithParts[], model: Provider.Model, options?: { stripMedia?: boolean; toolOutputMaxChars?: number }): Promise<import("ai").ModelMessage[]> {
-  return Effect.runPromise(toModelMessagesEffect(input, model, options).pipe(Effect.provide(EffectLogger.layer)))
-}
+export * from "./message/message-transform"