bonecode 1.0.0

package/src/engine/session/message.ts

@@ -0,0 +1,146 @@
+import { Schema } from "effect"
+import { SessionID } from "./schema"
+import { ModelID, ProviderID } from "../provider/schema"
+import { NonNegativeInt } from "@opencode-ai/core/schema"
+import { MessageError } from "./message-error"
+import { AuthError, OutputLengthError } from "./message-error"
+export { AuthError, OutputLengthError } from "./message-error"
+
+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" })
+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" })
+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" })
+export type ToolResult = Schema.Schema.Type<typeof ToolResult>
+
+export const ToolInvocation = Schema.Union([ToolCall, ToolPartialCall, ToolResult]).annotate({
+  identifier: "ToolInvocation",
+  discriminator: "state",
+})
+export type ToolInvocation = Schema.Schema.Type<typeof ToolInvocation>
+
+export const TextPart = Schema.Struct({
+  type: Schema.Literal("text"),
+  text: Schema.String,
+}).annotate({ identifier: "TextPart" })
+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" })
+export type ReasoningPart = Schema.Schema.Type<typeof ReasoningPart>
+
+export const ToolInvocationPart = Schema.Struct({
+  type: Schema.Literal("tool-invocation"),
+  toolInvocation: ToolInvocation,
+}).annotate({ identifier: "ToolInvocationPart" })
+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" })
+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" })
+export type FilePart = Schema.Schema.Type<typeof FilePart>
+
+export const StepStartPart = Schema.Struct({
+  type: Schema.Literal("step-start"),
+}).annotate({ identifier: "StepStartPart" })
+export type StepStartPart = Schema.Schema.Type<typeof StepStartPart>
+
+export const MessagePart = Schema.Union([
+  TextPart,
+  ReasoningPart,
+  ToolInvocationPart,
+  SourceUrlPart,
+  FilePart,
+  StepStartPart,
+]).annotate({ identifier: "MessagePart", discriminator: "type" })
+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(MessageError.SharedSchema),
+    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: Schema.Finite,
+          output: Schema.Finite,
+          reasoning: Schema.Finite,
+          cache: Schema.Struct({
+            read: Schema.Finite,
+            write: Schema.Finite,
+          }),
+        }),
+      }),
+    ),
+    snapshot: Schema.optional(Schema.String),
+  }).annotate({ identifier: "MessageMetadata" }),
+}).annotate({ identifier: "Message" })
+export type Info = Schema.Schema.Type<typeof Info>
+
+export * as Message from "./message"

package/src/engine/session/overflow.ts

@@ -0,0 +1,32 @@
+import type { Config } from "@/config/config"
+import type { Provider } from "@/provider/provider"
+import { ProviderTransform } from "@/provider/transform"
+import type { MessageV2 } from "./message-v2"
+
+const COMPACTION_BUFFER = 20_000
+
+export function usable(input: { cfg: Config.Info; model: Provider.Model; outputTokenMax?: number }) {
+  const context = input.model.limit.context
+  if (context === 0) return 0
+
+  const reserved =
+    input.cfg.compaction?.reserved ??
+    Math.min(COMPACTION_BUFFER, ProviderTransform.maxOutputTokens(input.model, input.outputTokenMax))
+  return input.model.limit.input
+    ? Math.max(0, input.model.limit.input - reserved)
+    : Math.max(0, context - ProviderTransform.maxOutputTokens(input.model, input.outputTokenMax))
+}
+
+export function isOverflow(input: {
+  cfg: Config.Info
+  tokens: MessageV2.Assistant["tokens"]
+  model: Provider.Model
+  outputTokenMax?: number
+}) {
+  if (input.cfg.compaction?.auto === false) return false
+  if (input.model.limit.context === 0) return false
+
+  const count =
+    input.tokens.total || input.tokens.input + input.tokens.output + input.tokens.cache.read + input.tokens.cache.write
+  return count >= usable(input)
+}

package/src/engine/session/overflow_check.ts

@@ -0,0 +1,46 @@
+/**
+ * Context overflow detection — ported from OpenCode's session/overflow.ts
+ * Uses model context limits from env config since we don't have the full
+ * Provider service. Falls back to conservative 80% threshold.
+ */
+
+const COMPACTION_BUFFER = 20_000;
+
+// Model context window limits (tokens). Extend as needed.
+const MODEL_CONTEXT_LIMITS: Record<string, number> = {
+  "claude-opus-4-5": 200_000,
+  "claude-sonnet-4-5": 200_000,
+  "claude-haiku-3-5": 200_000,
+  "gpt-4o": 128_000,
+  "gpt-4o-mini": 128_000,
+  "o1": 200_000,
+  "o3-mini": 200_000,
+  "gemini-2.0-flash": 1_000_000,
+  "gemini-1.5-pro": 2_000_000,
+};
+
+function getContextLimit(model_id: string): number {
+  // Exact match
+  if (MODEL_CONTEXT_LIMITS[model_id]) return MODEL_CONTEXT_LIMITS[model_id];
+  // Prefix match
+  for (const [key, limit] of Object.entries(MODEL_CONTEXT_LIMITS)) {
+    if (model_id.includes(key) || key.includes(model_id)) return limit;
+  }
+  // Default: 128k
+  return 128_000;
+}
+
+export function isOverflow(
+  tokens: { input?: number; output?: number; total?: number; cache?: { read?: number; write?: number } },
+  model_id: string
+): boolean {
+  const limit = getContextLimit(model_id);
+  if (limit === 0) return false;
+
+  const count = tokens.total ||
+    (tokens.input || 0) + (tokens.output || 0) +
+    (tokens.cache?.read || 0) + (tokens.cache?.write || 0);
+
+  const usable = Math.max(0, limit - COMPACTION_BUFFER - 32_000); // reserve output tokens
+  return count >= usable;
+}