amalgm 0.0.0 → 0.0.1

package/runtime/lib/chatInput.js

@@ -0,0 +1,306 @@
+const { z } = require('zod');
+
+const VALID_AUTH_METHODS = ['amalgm', 'byok', 'provider_auth'];
+
+const ChatInputTextPartSchema = z.object({
+  type: z.literal('text'),
+  text: z.string().default(''),
+}).passthrough();
+
+const ChatInputFilePartSchema = z.object({
+  type: z.literal('file'),
+  filename: z.string().optional(),
+  mediaType: z.string().optional(),
+  url: z.string().optional(),
+  storagePath: z.string().optional(),
+  storage_path: z.string().optional(),
+  computerPath: z.string().optional(),
+  sandboxPath: z.string().optional(),
+  assetId: z.string().optional(),
+}).passthrough();
+
+const ChatInputUnknownPartSchema = z.object({
+  type: z.string(),
+}).passthrough();
+
+const ChatInputPartSchema = z.union([
+  ChatInputTextPartSchema,
+  ChatInputFilePartSchema,
+  ChatInputUnknownPartSchema,
+]);
+
+const WorkspaceTargetSchema = z.discriminatedUnion('kind', [
+  z.object({
+    kind: z.literal('cwd'),
+    cwd: z.string(),
+  }),
+  z.object({
+    kind: z.literal('existing-worktree'),
+    path: z.string(),
+  }),
+  z.object({
+    kind: z.literal('managed-worktree'),
+    repoPath: z.string(),
+    branch: z.string(),
+    baseBranch: z.string().nullable().optional(),
+    path: z.string().nullable().optional(),
+  }),
+]);
+
+const ChatInputSchema = z.object({
+  parts: z.array(ChatInputPartSchema).default([]),
+  agent: z.object({
+    harness: z.string().nullable().optional(),
+    model: z.string().nullable().optional(),
+    authMethod: z.enum(VALID_AUTH_METHODS).nullable().optional(),
+    customAgentId: z.string().nullable().optional(),
+    systemPrompt: z.string().nullable().optional(),
+  }).default({}),
+  tools: z.object({
+    mcpAppIds: z.array(z.string()).default([]),
+  }).default({}),
+  execution: z.object({
+    cwd: z.string().nullable().optional(),
+    computerId: z.string().nullable().optional(),
+    workspace: WorkspaceTargetSchema.nullable().optional(),
+  }).default({}),
+});
+
+function isObject(value) {
+  return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+
+function cleanString(value) {
+  return typeof value === 'string' && value.trim() ? value : null;
+}
+
+function firstString(...values) {
+  for (const value of values) {
+    const cleaned = cleanString(value);
+    if (cleaned) return cleaned;
+  }
+  return null;
+}
+
+function uniqueStrings(values) {
+  if (!Array.isArray(values)) return [];
+  return [...new Set(values.filter((value) => typeof value === 'string' && value.trim()).map((value) => value.trim()))];
+}
+
+function normalizeWorkspace(rawWorkspace, fallbackCwd) {
+  if (isObject(rawWorkspace) && typeof rawWorkspace.kind === 'string') {
+    const parsed = WorkspaceTargetSchema.safeParse(rawWorkspace);
+    if (parsed.success) return parsed.data;
+  }
+
+  const cwd = cleanString(fallbackCwd);
+  return cwd ? { kind: 'cwd', cwd } : null;
+}
+
+function getWorkspaceCwd(workspace) {
+  if (!workspace || !isObject(workspace)) return null;
+  if (workspace.kind === 'cwd' && cleanString(workspace.cwd)) return workspace.cwd.trim();
+  if (workspace.kind === 'existing-worktree' && cleanString(workspace.path)) return workspace.path.trim();
+  if (workspace.kind === 'managed-worktree') {
+    return firstString(workspace.path, workspace.repoPath);
+  }
+  return null;
+}
+
+function normalizeChatPart(part) {
+  if (!isObject(part) || typeof part.type !== 'string') return null;
+
+  if (part.type === 'text') {
+    return {
+      ...part,
+      type: 'text',
+      text: typeof part.text === 'string' ? part.text : '',
+    };
+  }
+
+  if (part.type === 'file') {
+    const storagePath = firstString(part.storagePath, part.storage_path);
+    const computerPath = firstString(part.computerPath, part.sandboxPath);
+    return {
+      ...part,
+      type: 'file',
+      ...(cleanString(part.filename) ? { filename: part.filename.trim() } : {}),
+      ...(cleanString(part.mediaType) ? { mediaType: part.mediaType.trim() } : {}),
+      ...(cleanString(part.url) ? { url: part.url.trim() } : {}),
+      ...(storagePath ? { storagePath, storage_path: storagePath } : {}),
+      ...(computerPath ? { computerPath, sandboxPath: computerPath } : {}),
+      ...(cleanString(part.assetId) ? { assetId: part.assetId.trim() } : {}),
+    };
+  }
+
+  return { ...part };
+}
+
+function normalizeChatParts(parts, fallbackPrompt) {
+  const normalized = Array.isArray(parts)
+    ? parts.map(normalizeChatPart).filter(Boolean)
+    : [];
+
+  if (normalized.length > 0) return normalized;
+
+  const prompt = typeof fallbackPrompt === 'string' ? fallbackPrompt : '';
+  return prompt.trim() ? [{ type: 'text', text: prompt }] : [];
+}
+
+function getChatInputText(chatInput, fallbackPrompt) {
+  const normalized = normalizeChatInput(chatInput, { prompt: fallbackPrompt });
+  return normalized.parts
+    .filter((part) => part.type === 'text' && typeof part.text === 'string')
+    .map((part) => part.text)
+    .join('\n\n')
+    .trim();
+}
+
+function getAttachedFilePaths(parts) {
+  if (!Array.isArray(parts)) return [];
+  return parts
+    .filter((part) => part && part.type === 'file')
+    .map((part) => firstString(part.computerPath, part.sandboxPath))
+    .filter(Boolean);
+}
+
+function buildPromptFromParts(parts, fallbackPrompt) {
+  const normalizedParts = normalizeChatParts(parts, fallbackPrompt);
+  const text = normalizedParts
+    .filter((part) => part.type === 'text' && typeof part.text === 'string')
+    .map((part) => part.text)
+    .join('\n\n')
+    .trim();
+  const attachedPaths = getAttachedFilePaths(normalizedParts);
+
+  if (attachedPaths.length === 0) {
+    return text || (typeof fallbackPrompt === 'string' ? fallbackPrompt : '');
+  }
+
+  const attachedPrefix = `[Attached files: ${attachedPaths.join(', ')}]`;
+  return text ? `${attachedPrefix}\n\n${text}` : attachedPrefix;
+}
+
+function normalizeChatInput(chatInput, legacy = {}) {
+  const rawInput = isObject(chatInput) ? chatInput : {};
+  const rawAgent = isObject(rawInput.agent) ? rawInput.agent : {};
+  const rawTools = isObject(rawInput.tools) ? rawInput.tools : {};
+  const rawExecution = isObject(rawInput.execution) ? rawInput.execution : {};
+
+  const workspace = normalizeWorkspace(
+    rawExecution.workspace,
+    firstString(rawExecution.cwd, legacy.cwd, legacy.projectPath),
+  );
+  const resolvedCwd = firstString(
+    rawExecution.cwd,
+    getWorkspaceCwd(workspace),
+    legacy.cwd,
+    legacy.projectPath,
+  );
+
+  const normalized = {
+    parts: normalizeChatParts(
+      rawInput.parts,
+      Array.isArray(legacy.userParts) && legacy.userParts.length > 0
+        ? null
+        : legacy.prompt,
+    ),
+    agent: {
+      harness: firstString(rawAgent.harness, rawAgent.harnessId, legacy.harness),
+      model: firstString(rawAgent.model, rawAgent.modelId, legacy.modelId, legacy.model),
+      authMethod: firstString(rawAgent.authMethod, legacy.authMethod),
+      customAgentId: firstString(
+        rawAgent.customAgentId,
+        (typeof rawAgent.harness === 'string' && rawAgent.harness.startsWith('custom-'))
+          ? rawAgent.harness
+          : null,
+        (typeof legacy.harness === 'string' && legacy.harness.startsWith('custom-'))
+          ? legacy.harness
+          : null,
+      ),
+      systemPrompt: firstString(rawAgent.systemPrompt, legacy.systemPrompt),
+    },
+    tools: {
+      mcpAppIds: uniqueStrings(rawTools.mcpAppIds || legacy.mcpAppIds),
+    },
+    execution: {
+      cwd: resolvedCwd,
+      computerId: firstString(rawExecution.computerId, legacy.computerId),
+      workspace,
+    },
+  };
+
+  return ChatInputSchema.parse(normalized);
+}
+
+function chatInputToLegacyFields(chatInput, fallback = {}) {
+  const normalized = normalizeChatInput(chatInput, fallback);
+  const prompt = buildPromptFromParts(normalized.parts, fallback.prompt);
+  const harness = firstString(
+    normalized.agent.customAgentId,
+    normalized.agent.harness,
+    fallback.harness,
+  );
+  const modelId = firstString(
+    normalized.agent.model,
+    fallback.modelId,
+    fallback.model,
+  );
+  const cwd = firstString(
+    normalized.execution.cwd,
+    getWorkspaceCwd(normalized.execution.workspace),
+    fallback.cwd,
+    fallback.projectPath,
+  );
+  const authMethod = firstString(
+    normalized.agent.authMethod,
+    fallback.authMethod,
+  );
+  const systemPrompt = firstString(
+    normalized.agent.systemPrompt,
+    fallback.systemPrompt,
+  );
+
+  return {
+    prompt,
+    userParts: normalized.parts,
+    harness,
+    modelId,
+    model: modelId,
+    authMethod,
+    cwd,
+    projectPath: cwd,
+    computerId: firstString(normalized.execution.computerId, fallback.computerId),
+    mcpAppIds: normalized.tools.mcpAppIds,
+    systemPrompt,
+  };
+}
+
+function withChatInputText(chatInput, updater, legacy = {}) {
+  const normalized = normalizeChatInput(chatInput, legacy);
+  const parts = normalized.parts.map((part) => {
+    if (part.type !== 'text' || typeof part.text !== 'string') return part;
+    const nextText = updater(part.text, part);
+    return {
+      ...part,
+      text: typeof nextText === 'string' ? nextText : part.text,
+    };
+  });
+  return normalizeChatInput({ ...normalized, parts });
+}
+
+module.exports = {
+  ChatInputPartSchema,
+  ChatInputSchema,
+  WorkspaceTargetSchema,
+  buildPromptFromParts,
+  chatInputToLegacyFields,
+  getAttachedFilePaths,
+  getChatInputText,
+  getWorkspaceCwd,
+  normalizeChatInput,
+  normalizeChatPart,
+  normalizeChatParts,
+  uniqueStrings,
+  withChatInputText,
+};