amalgm 0.0.0 → 0.0.1

package/runtime/scripts/chat-core/engine.js

@@ -0,0 +1,195 @@
+'use strict';
+
+const { PartAccumulator } = require('./parts');
+const { assertSameContract, createContract } = require('./contract');
+const { done, errorEvent } = require('./events');
+const { normalizeInput } = require('./input');
+const { frameFor, titleFrame } = require('./sse');
+const { beginProxyTurn, logTurnUsage } = require('./usage');
+
+function assertDbSaved(result, label) {
+  if (result === false || result === null) {
+    throw new Error(`${label} was not saved; keeping temp/raw stream for reconnect`);
+  }
+}
+
+class ChatCore {
+  constructor({ db, runtime, turns, options = {} }) {
+    this.db = db;
+    this.runtime = runtime;
+    this.turns = turns;
+    this.options = options;
+    this.beginTurn = options.beginTurn || beginProxyTurn;
+    this.contracts = new Map();
+  }
+
+  contractFor(payload) {
+    const next = createContract(payload, this.options);
+    const existing = this.contracts.get(next.sessionId);
+    if (existing) assertSameContract(existing, next);
+    this.contracts.set(next.sessionId, next);
+    return next;
+  }
+
+  active(sessionId) {
+    const entry = this.turns.active(sessionId);
+    return {
+      active: !!entry && ['streaming', 'cancelling'].includes(entry.status),
+      codeSessionId: sessionId,
+      assistantMessageId: entry?.assistantMessageId || null,
+      status: entry?.status || 'idle',
+    };
+  }
+
+  async stop(sessionId) {
+    const entry = this.turns.active(sessionId);
+    if (!entry) return false;
+    this.turns.mark(entry.turnId, 'cancelling');
+    await this.runtime.stop(sessionId);
+    return true;
+  }
+
+  async destroy(sessionId) {
+    this.contracts.delete(sessionId);
+    return this.runtime.destroy(sessionId);
+  }
+
+  async runTurn(payload, writeFrame) {
+    const contract = this.contractFor(payload);
+    await this.beginTurn(contract);
+    const input = normalizeInput(payload);
+    let runtimeInput = input;
+    const isReturningToSession = !!payload.resumeSessionId && payload.resumeSessionId !== 'new';
+    const runtimeWasWarm = !!this.runtime.get(contract.sessionId);
+    const turnId = contract.assistantMessageId;
+    const msgConfig = {
+      ...payload,
+      prompt: input.text,
+      userParts: input.parts,
+      codeSessionId: contract.sessionId,
+      assistantMessageId: contract.assistantMessageId,
+      modelId: contract.usageModelId || contract.modelId,
+    };
+    assertDbSaved(await this.db.saveUserMessage(msgConfig), 'User message');
+    if (isReturningToSession && !runtimeWasWarm && !contract.providerSessionId && typeof this.db.loadConversationHistory === 'function') {
+      try {
+        const history = await this.db.loadConversationHistory(contract.sessionId, contract.userMessageId);
+        if (history) {
+          const text = `${history}${input.text || ''}`.trim();
+          runtimeInput = {
+            ...input,
+            text,
+            parts: [{ type: 'text', text }],
+          };
+        }
+      } catch (err) {
+        console.warn('[ChatCore] Failed to load cold-resume conversation history:', err.message);
+      }
+    }
+    assertDbSaved(await this.db.ensureAssistantMessage(msgConfig), 'Assistant placeholder');
+    await this.db.mergeSessionMetadata(contract.sessionId, {
+      contract: {
+        userId: contract.userId,
+        computerId: contract.computerId,
+        harness: contract.harness,
+        authMethod: contract.authMethod,
+        modelId: contract.modelId,
+        usageModelId: contract.usageModelId,
+        providerSessionId: contract.providerSessionId,
+        cliModel: contract.cliModel,
+        reasoningEffort: contract.reasoningEffort,
+        cwd: contract.cwd,
+        runtimeKey: contract.runtimeKey,
+        systemPromptConfigured: !!contract.systemPrompt,
+        mcpServers: contract.mcpServers.map((server) => ({
+          name: server?.name,
+          type: server?.type,
+          url: server?.url,
+          hasHeaders: Array.isArray(server?.headers) && server.headers.length > 0,
+        })),
+        auth: {
+          baseUrl: contract.auth.baseUrl,
+          tokenFingerprint: contract.auth.tokenFingerprint,
+          runtimeHome: contract.auth.runtimeHome,
+        },
+      },
+    }).catch(() => {});
+
+    const entry = this.turns.start({
+      sessionId: contract.sessionId,
+      turnId,
+      assistantMessageId: contract.assistantMessageId,
+      userMessageId: contract.userMessageId,
+    });
+
+    if (typeof this.db.generateAndSaveTitle === 'function' && input.text) {
+      this.db.generateAndSaveTitle(contract.sessionId, input.text, (title) => {
+        const frame = titleFrame({ sessionId: contract.sessionId, title });
+        this.turns.addChunk(turnId, frame);
+        if (writeFrame) writeFrame(frame);
+      }).catch((err) => {
+        console.warn('[ChatCore] Title generation failed:', err.message);
+      });
+    }
+
+    const parts = new PartAccumulator();
+    let usage = null;
+    const usageRecords = [];
+    let providerSessionId = contract.providerSessionId || null;
+    let stopReason = 'end_turn';
+    let sawDone = false;
+
+    const append = (e) => {
+      if (e.providerSessionId) providerSessionId = e.providerSessionId;
+      if (e.type === 'usage.final') {
+        usage = e.usage;
+        usageRecords.push(e.usage);
+      }
+      if (e.type === 'done') {
+        sawDone = true;
+        stopReason = e.stopReason || stopReason;
+      }
+      parts.apply(e);
+      const frame = frameFor(e, { sessionId: contract.sessionId, providerSessionId, usage });
+      this.turns.addChunk(turnId, frame);
+      if (writeFrame) writeFrame(frame);
+    };
+
+    try {
+      const stream = await this.runtime.prompt(contract, runtimeInput);
+      for await (const e of stream) append(e);
+      const current = this.turns.get(turnId);
+      if (!sawDone) {
+        append(done({
+          providerSessionId,
+          stopReason: current?.status === 'cancelling' ? 'cancelled' : stopReason,
+        }));
+      }
+    } catch (err) {
+      append(errorEvent(err.message, { providerSessionId }));
+      append(done({ providerSessionId, stopReason: 'error' }));
+      stopReason = 'error';
+    }
+
+    const savedParts = parts.finalize();
+    this.turns.setParts(turnId, savedParts);
+    try {
+      assertDbSaved(await this.db.saveAssistantMessage(msgConfig, savedParts, providerSessionId, usage), 'Assistant message');
+    } catch (saveErr) {
+      this.turns.mark(turnId, 'save_failed');
+      throw saveErr;
+    }
+    this.turns.mark(turnId, stopReason === 'error' ? 'error' : stopReason === 'cancelled' ? 'cancelled' : 'complete');
+    this.turns.clear(turnId);
+    await logTurnUsage({
+      db: this.db,
+      contract,
+      messageId: contract.assistantMessageId,
+      usage,
+      usageRecords,
+    });
+    return { providerSessionId, usage, parts: savedParts, stopReason };
+  }
+}
+
+module.exports = { ChatCore };

package/runtime/scripts/chat-core/event-schema.js

@@ -0,0 +1,231 @@
+'use strict';
+
+const { z } = require('zod');
+
+const positiveNumber = z.number().finite().positive();
+const nonNegativeNumber = z.number().finite().min(0);
+const nullablePositiveNumber = positiveNumber.nullable();
+const providerSessionId = z.string().nullable().optional();
+const unknownRecord = z.record(z.string(), z.unknown());
+
+const rawEnvelope = z.object({
+  source: z.string().min(1),
+  method: z.string().min(1).optional(),
+  payload: z.unknown().optional(),
+}).strict();
+
+const toolKind = z.enum([
+  'web_search',
+  'browser',
+  'file_read',
+  'file_write',
+  'file_edit',
+  'bash',
+  'subagent',
+  'mcp',
+  'question',
+  'todo',
+  'unknown',
+  // Legacy ACP-ish kinds still emitted by older callers.
+  'read',
+  'edit',
+  'delete',
+  'move',
+  'search',
+  'execute',
+  'think',
+  'fetch',
+  'switch_mode',
+  'other',
+]);
+
+const toolTiming = z.object({
+  startedAt: z.union([z.string(), z.number()]).optional(),
+  completedAt: z.union([z.string(), z.number()]).optional(),
+  elapsedMs: nonNegativeNumber.optional(),
+}).passthrough();
+
+const toolError = z.object({
+  message: z.string(),
+  code: z.string().optional(),
+  details: z.unknown().optional(),
+}).passthrough();
+
+const baseEvent = z.object({
+  ts: z.number().finite(),
+  providerSessionId,
+  raw: rawEnvelope.optional(),
+}).passthrough();
+
+const tokenList = z.object({
+  input: nonNegativeNumber,
+  output: nonNegativeNumber,
+  cacheRead: nonNegativeNumber,
+  cacheWrite: nonNegativeNumber,
+  thought: nonNegativeNumber,
+  total: nonNegativeNumber,
+}).strict();
+
+const usageSnapshot = z.object({
+  tokenList,
+  cumulativeTokenList: tokenList.nullable(),
+  previousCumulativeTokenList: tokenList.nullable(),
+  inputTokens: nonNegativeNumber,
+  outputTokens: nonNegativeNumber,
+  cacheReadTokens: nonNegativeNumber,
+  cacheWriteTokens: nonNegativeNumber,
+  thoughtTokens: nonNegativeNumber,
+  inputContextSize: nonNegativeNumber,
+  contextUsedTokens: nullablePositiveNumber,
+  contextLimit: nullablePositiveNumber,
+  usedTokens: nullablePositiveNumber,
+  lastUsedTokens: nullablePositiveNumber,
+  maxTokens: nullablePositiveNumber,
+  totalProcessedTokens: nullablePositiveNumber,
+  costUsd: z.number().finite().nullable(),
+  marketCostUsd: z.number().finite().nullable(),
+  operation: z.string().min(1),
+  billable: z.boolean(),
+  source: z.string().min(1),
+  exact: z.boolean(),
+}).strict();
+
+const textDeltaEvent = baseEvent.extend({
+  type: z.literal('text.delta'),
+  text: z.string(),
+  streamKind: z.literal('text').optional(),
+}).strict();
+
+const reasoningDeltaEvent = baseEvent.extend({
+  type: z.literal('reasoning.delta'),
+  text: z.string(),
+  streamKind: z.union([z.literal('reasoning'), z.literal('plan')]).optional(),
+}).strict();
+
+const toolStartedEvent = baseEvent.extend({
+  type: z.literal('tool.started'),
+  toolCallId: z.string(),
+  toolName: z.string().min(1),
+  name: z.string().min(1).optional(),
+  kind: toolKind.optional(),
+  title: z.string().optional(),
+  detail: z.string().optional(),
+  input: unknownRecord,
+  metadata: unknownRecord.optional(),
+  timing: toolTiming.optional(),
+  data: z.unknown().optional(),
+  itemType: z.literal('tool').optional(),
+}).strict();
+
+const toolUpdatedEvent = baseEvent.extend({
+  type: z.literal('tool.updated'),
+  toolCallId: z.string(),
+  toolName: z.string().optional(),
+  name: z.string().optional(),
+  kind: toolKind.optional(),
+  title: z.string().optional(),
+  detail: z.string().optional(),
+  inputDelta: unknownRecord.optional(),
+  outputDelta: z.unknown().optional(),
+  output: z.unknown().optional(),
+  error: toolError.optional(),
+  metadata: unknownRecord.optional(),
+  timing: toolTiming.optional(),
+  data: z.unknown().optional(),
+  status: z.enum(['in_progress', 'completed', 'failed', 'error']).optional(),
+  itemType: z.literal('tool').optional(),
+}).strict();
+
+const toolCompletedEvent = baseEvent.extend({
+  type: z.literal('tool.completed'),
+  toolCallId: z.string(),
+  toolName: z.string().optional(),
+  name: z.string().optional(),
+  kind: toolKind.optional(),
+  title: z.string().optional(),
+  detail: z.string().optional(),
+  input: unknownRecord.optional(),
+  output: z.unknown().optional(),
+  result: z.unknown().optional(),
+  error: toolError.optional(),
+  metadata: unknownRecord.optional(),
+  timing: toolTiming.optional(),
+  data: z.unknown().optional(),
+  isError: z.boolean(),
+  itemType: z.literal('tool').optional(),
+}).strict();
+
+const usageFinalEvent = baseEvent.extend({
+  type: z.literal('usage.final'),
+  usage: usageSnapshot,
+}).strict();
+
+const warningEvent = baseEvent.extend({
+  type: z.literal('warning'),
+  message: z.string(),
+  requestedModel: z.string().optional(),
+}).strict();
+
+const errorEvent = baseEvent.extend({
+  type: z.literal('error'),
+  message: z.string(),
+}).strict();
+
+const doneEvent = baseEvent.extend({
+  type: z.literal('done'),
+  stopReason: z.string(),
+  usage: usageSnapshot.optional(),
+}).strict();
+
+const compactionTrigger = z.enum(['auto', 'manual', 'model_triggered']);
+
+const compactionStartedEvent = baseEvent.extend({
+  type: z.literal('compaction.started'),
+  trigger: compactionTrigger,
+}).strict();
+
+const compactionFinishedEvent = baseEvent.extend({
+  type: z.literal('compaction.finished'),
+  trigger: compactionTrigger,
+  preTokens: nullablePositiveNumber.optional(),
+  postTokens: nullablePositiveNumber.optional(),
+  durationMs: nullablePositiveNumber.optional(),
+}).strict();
+
+const amalgmEventSchema = z.discriminatedUnion('type', [
+  textDeltaEvent,
+  reasoningDeltaEvent,
+  toolStartedEvent,
+  toolUpdatedEvent,
+  toolCompletedEvent,
+  usageFinalEvent,
+  compactionStartedEvent,
+  compactionFinishedEvent,
+  warningEvent,
+  errorEvent,
+  doneEvent,
+]);
+
+function formatZodIssue(issue) {
+  return `${issue.path.join('.') || '<event>'}: ${issue.message}`;
+}
+
+function validateAmalgmEvent(value) {
+  const parsed = amalgmEventSchema.safeParse(value);
+  if (parsed.success) return parsed.data;
+
+  const type = value && typeof value === 'object' ? value.type : typeof value;
+  const details = parsed.error.issues.map(formatZodIssue).join('; ');
+  throw new Error(`Invalid Amalgm event ${String(type || 'unknown')}: ${details}`);
+}
+
+function validateAmalgmEvents(events) {
+  return events.map(validateAmalgmEvent);
+}
+
+module.exports = {
+  amalgmEventSchema,
+  usageSnapshot,
+  validateAmalgmEvent,
+  validateAmalgmEvents,
+};

package/runtime/scripts/chat-core/events.js

@@ -0,0 +1,190 @@
+'use strict';
+
+const { validateAmalgmEvent } = require('./event-schema');
+const { withActionDescriptor, withOutputDescriptor } = require('./tool-display');
+const { mcpMetadataFromName, normalizeError, titleForTool, toolKind } = require('./tool-shape');
+
+function now(ts) {
+  return Number.isFinite(ts) ? ts : Date.now();
+}
+
+function event(type, data = {}) {
+  const { ts, ...rest } = data;
+  const next = { type, ts: now(ts), ...rest };
+  if (process.env.CHAT_CORE_VALIDATE_EVENTS === '0') return next;
+  return validateAmalgmEvent(next);
+}
+
+function textDelta(text, data = {}) {
+  return event('text.delta', { streamKind: 'text', ...data, text: String(text || '') });
+}
+
+function reasoningDelta(text, data = {}) {
+  return event('reasoning.delta', { streamKind: 'reasoning', ...data, text: String(text || '') });
+}
+
+function reasoningStarted(data = {}) {
+  return reasoningDelta('', data);
+}
+
+function toolStarted(id, data = {}) {
+  const toolName = data.toolName || data.title || 'unknown';
+  const input = withActionDescriptor(data.input, data.detail);
+  const metadata = { ...mcpMetadataFromName(toolName), ...(data.metadata || {}) };
+  return event('tool.started', {
+    ...data,
+    itemType: 'tool',
+    toolCallId: String(id || ''),
+    toolName,
+    name: toolName,
+    kind: data.kind || toolKind(toolName, input, metadata),
+    title: titleForTool({ name: toolName, input, metadata, fallback: data.title || data.detail }),
+    input,
+    metadata,
+    timing: data.timing,
+  });
+}
+
+function toolUpdated(id, data = {}) {
+  const toolName = data.toolName || data.title || 'unknown';
+  const inputDelta = data.inputDelta ? withActionDescriptor(data.inputDelta, data.detail) : undefined;
+  const metadata = { ...mcpMetadataFromName(toolName), ...(data.metadata || {}) };
+  return event('tool.updated', {
+    itemType: 'tool',
+    ...data,
+    toolCallId: String(id || ''),
+    toolName,
+    name: toolName,
+    kind: data.kind || toolKind(toolName, inputDelta || {}, metadata),
+    title: titleForTool({ name: toolName, input: inputDelta || {}, output: data.output, metadata, fallback: data.title || data.detail }),
+    metadata,
+    timing: data.timing,
+    ...(inputDelta ? { inputDelta } : {}),
+    ...(data.output !== undefined ? { output: withOutputDescriptor(data.output, data.detail) } : {}),
+    ...(data.error ? { error: normalizeError(data.error) } : {}),
+  });
+}
+
+function toolCompleted(id, data = {}) {
+  const toolName = data.toolName || data.title || 'unknown';
+  const input = data.input ? withActionDescriptor(data.input, data.detail) : undefined;
+  const output = data.output !== undefined ? withOutputDescriptor(data.output, data.detail) : undefined;
+  const metadata = { ...mcpMetadataFromName(toolName), ...(data.metadata || {}) };
+  const error = data.error || (data.isError === true ? data.output ?? data.result ?? data.detail : undefined);
+  return event('tool.completed', {
+    ...data,
+    itemType: 'tool',
+    toolCallId: String(id || ''),
+    toolName,
+    name: toolName,
+    kind: data.kind || toolKind(toolName, input || {}, metadata),
+    title: titleForTool({ name: toolName, input: input || {}, output, error, metadata, fallback: data.title || data.detail }),
+    ...(input ? { input } : {}),
+    ...(output !== undefined ? { output } : {}),
+    ...(error ? { error: normalizeError(error) } : {}),
+    metadata,
+    timing: data.timing,
+    isError: data.isError === true,
+  });
+}
+
+function usageFinal(usage, data = {}) {
+  const tokenList = usageTokenList(usage);
+  const inputContextSize = usageInputContextSize(usage, tokenList);
+  return event('usage.final', {
+    ...data,
+    usage: {
+      tokenList,
+      cumulativeTokenList: usage?.cumulativeTokenList || null,
+      previousCumulativeTokenList: usage?.previousCumulativeTokenList || null,
+      inputTokens: tokenList.input,
+      outputTokens: tokenList.output,
+      cacheReadTokens: tokenList.cacheRead,
+      cacheWriteTokens: tokenList.cacheWrite,
+      thoughtTokens: tokenList.thought,
+      inputContextSize,
+      contextUsedTokens: finiteOrNull(usage?.contextUsedTokens ?? usage?.usedTokens ?? inputContextSize),
+      contextLimit: finiteOrNull(usage?.contextLimit ?? usage?.maxTokens ?? usage?.modelContextWindow),
+      usedTokens: finiteOrNull(usage?.usedTokens ?? usage?.contextUsedTokens ?? inputContextSize),
+      lastUsedTokens: finiteOrNull(usage?.lastUsedTokens ?? usage?.contextUsedTokens ?? usage?.usedTokens ?? inputContextSize),
+      maxTokens: finiteOrNull(usage?.maxTokens ?? usage?.contextLimit ?? usage?.modelContextWindow),
+      totalProcessedTokens: finiteOrNull(usage?.totalProcessedTokens),
+      costUsd: usage?.costUsd ?? null,
+      marketCostUsd: usage?.marketCostUsd ?? null,
+      operation: String(usage?.operation || 'chat_step'),
+      billable: usage?.billable !== false,
+      source: usage?.source || 'unknown',
+      exact: usage?.exact === true,
+    },
+  });
+}
+
+function usageTokenList(usage = {}) {
+  const source = usage?.tokenList && typeof usage.tokenList === 'object' ? usage.tokenList : {};
+  const input = finiteNonNegativeOrNull(source.input ?? source.inputTokens ?? usage?.inputTokens) ?? 0;
+  const output = finiteNonNegativeOrNull(source.output ?? source.outputTokens ?? usage?.outputTokens) ?? 0;
+  const cacheRead = finiteNonNegativeOrNull(source.cacheRead ?? source.cacheReadTokens ?? usage?.cacheReadTokens) ?? 0;
+  const cacheWrite = finiteNonNegativeOrNull(source.cacheWrite ?? source.cacheWriteTokens ?? usage?.cacheWriteTokens) ?? 0;
+  const thought = finiteNonNegativeOrNull(source.thought ?? source.thoughtTokens ?? usage?.thoughtTokens) ?? 0;
+  const total = finiteNonNegativeOrNull(source.total ?? source.totalTokens)
+    ?? input + output + cacheRead + cacheWrite;
+  return { input, output, cacheRead, cacheWrite, thought, total };
+}
+
+function usageInputContextSize(usage = {}, tokenList = usageTokenList(usage)) {
+  const explicit = finiteNonNegativeOrNull(usage?.inputContextSize ?? usage?.input_context_size);
+  if (explicit !== null) return explicit;
+  return tokenList.total;
+}
+
+function finiteNonNegativeOrNull(value) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : null;
+}
+
+function finiteOrNull(value) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+}
+
+function errorEvent(message, data = {}) {
+  return event('error', { ...data, message: String(message || 'Unknown error') });
+}
+
+function warningEvent(message, data = {}) {
+  return event('warning', { ...data, message: String(message || 'Runtime warning') });
+}
+
+function done(data = {}) {
+  return event('done', { ...data, stopReason: data.stopReason || 'end_turn' });
+}
+
+function compactionStarted(data = {}) {
+  return event('compaction.started', { ...data, trigger: data.trigger || 'auto' });
+}
+
+function compactionFinished(data = {}) {
+  return event('compaction.finished', {
+    ...data,
+    trigger: data.trigger || 'auto',
+    preTokens: finiteOrNull(data.preTokens),
+    postTokens: finiteOrNull(data.postTokens),
+    durationMs: finiteOrNull(data.durationMs),
+  });
+}
+
+module.exports = {
+  compactionFinished,
+  compactionStarted,
+  done,
+  errorEvent,
+  event,
+  reasoningDelta,
+  reasoningStarted,
+  textDelta,
+  toolCompleted,
+  toolStarted,
+  toolUpdated,
+  usageFinal,
+  warningEvent,
+};

package/runtime/scripts/chat-core/index.js

@@ -0,0 +1,11 @@
+'use strict';
+
+module.exports = {
+  ...require('./auth'),
+  ...require('./contract'),
+  ...require('./engine'),
+  ...require('./events'),
+  ...require('./runtime'),
+  ...require('./server'),
+  ...require('./stores'),
+};

package/runtime/scripts/chat-core/input.js

@@ -0,0 +1,50 @@
+'use strict';
+
+function textFromPart(part) {
+  if (!part || typeof part !== 'object') return '';
+  if (part.type === 'text' && typeof part.text === 'string') return part.text;
+  if (typeof part.content === 'string') return part.content;
+  return '';
+}
+
+function normalizeInput(payload) {
+  const chatInput = payload.chatInput && typeof payload.chatInput === 'object' ? payload.chatInput : null;
+  const parts = Array.isArray(payload.userParts) && payload.userParts.length > 0
+    ? payload.userParts
+    : Array.isArray(chatInput?.parts) && chatInput.parts.length > 0
+      ? chatInput.parts
+      : [{ type: 'text', text: payload.prompt || '' }];
+  const text = String(payload.prompt || parts.map(textFromPart).filter(Boolean).join('\n') || '').trim();
+  return {
+    text,
+    parts,
+    files: Array.isArray(chatInput?.files) ? chatInput.files : [],
+    systemPrompt: payload.systemPrompt || chatInput?.agent?.systemPrompt || '',
+    env: process.env,
+  };
+}
+
+function promptText(input, contract) {
+  const chunks = [];
+  if (input.files?.length) {
+    chunks.push(`<files>\n${input.files.map((file) => JSON.stringify(file)).join('\n')}\n</files>`);
+  }
+  chunks.push(input.text || '');
+  return chunks.filter(Boolean).join('\n\n');
+}
+
+function openCodeParts(input) {
+  const text = input.text || input.parts.map(textFromPart).filter(Boolean).join('\n');
+  const out = [];
+  if (text) out.push({ type: 'text', text });
+  for (const file of input.files || []) {
+    if (file?.path) out.push({ type: 'file', path: file.path });
+  }
+  return out.length ? out : [{ type: 'text', text: '' }];
+}
+
+module.exports = {
+  normalizeInput,
+  openCodeParts,
+  promptText,
+};