@atomicmemory/core 1.0.0

package/dist/routes/storage.js

@@ -0,0 +1,369 @@
+/**
+ * @file Direct storage API routes (`/v1/storage/*`).
+ *
+ * Step 3 added `GET /v1/storage/capabilities`; Step 5 adds the
+ * artifact CRUD surface on top of the same router:
+ *
+ *   POST   /v1/storage/artifacts            pointer (JSON body) or
+ *                                            ?mode=managed (raw bytes)
+ *   GET    /v1/storage/artifacts/:id        public metadata
+ *   GET    /v1/storage/artifacts/:id/content bytes (managed) or 409 (pointer)
+ *   HEAD   /v1/storage/artifacts/:id        metadata via response headers
+ *   DELETE /v1/storage/artifacts/:id?policy=...
+ *   POST   /v1/storage/artifacts/:id/verify backend.head()-based shim
+ *
+ * Body parsing is per-route:
+ *   * Pointer-mode put + verify use the standard JSON parser.
+ *   * Managed-mode put uses `express.raw({ type: '*\/*' })` with the
+ *     configured byte cap; the route extracts the caller-supplied
+ *     `X-AtomicMemory-Metadata` header (base64-encoded JSON) and
+ *     validates it against the decoded-JSON cap.
+ *
+ * Redaction posture: every public response runs through
+ * `formatStoredArtifact` (or its sibling formatters) which projects
+ * an allowlisted shape THEN `.strict()`-parses through the schema in
+ * `STORAGE_RESPONSE_SCHEMAS`. Internal columns (`stored_hash`,
+ * `last_error`, `delete_attempt_id`) never reach the wire.
+ */
+import express, { Router } from 'express';
+import { handleRouteError } from './route-errors.js';
+import { validateResponse } from '../middleware/validate-response.js';
+import { STORAGE_RESPONSE_SCHEMAS } from './response-schema-map.js';
+import { formatArtifactHeadHeaders, formatStoredArtifact, } from './storage-response-formatters.js';
+import { getStorageCapabilities, } from '../storage/storage-capabilities.js';
+import { InvalidArtifactMetadataError, StorageArtifactNotFoundError, } from '../services/storage-service-errors.js';
+import { LegacyUserIdRejection, handleStorageError, } from './storage-error-handlers.js';
+import { validateArtifactMetadata, } from '../services/storage-service.js';
+import { PutPointerBodySchema } from '../schemas/storage-schemas.js';
+const METADATA_HEADER = 'x-atomicmemory-metadata';
+const METADATA_HEADER_MAX_ENCODED_BYTES = 8 * 1024;
+const DEFAULT_JSON_LIMIT = '1mb';
+export function createStorageRouter(opts) {
+    const router = Router();
+    router.use(validateResponse(STORAGE_RESPONSE_SCHEMAS));
+    registerCapabilitiesRoute(router, opts.capabilities);
+    registerPutArtifactRoute(router, opts);
+    // HEAD MUST register before GET /:id — Express's auto-HEAD-from-GET
+    // path is picked when the GET handler is registered first, which
+    // suppresses our explicit `X-AtomicMemory-*` response headers.
+    registerHeadArtifactRoute(router, opts.service);
+    registerGetArtifactRoute(router, opts.service);
+    registerGetArtifactContentRoute(router, opts.service);
+    registerDeleteArtifactRoute(router, opts.service);
+    registerVerifyArtifactRoute(router, opts.service);
+    return router;
+}
+function registerCapabilitiesRoute(router, snapshot) {
+    router.get('/capabilities', (_req, res) => {
+        try {
+            res.json(getStorageCapabilities(snapshot));
+        }
+        catch (error) {
+            handleRouteError(res, 'get_storage_capabilities', error);
+        }
+    });
+}
+function registerPutArtifactRoute(router, opts) {
+    const rawParser = express.raw({
+        type: '*/*',
+        limit: opts.managedUploadMaxBytes,
+    });
+    const jsonParser = express.json({ limit: DEFAULT_JSON_LIMIT });
+    router.post('/artifacts', (req, res, next) => {
+        if (req.query.mode === 'managed')
+            return rawParser(req, res, next);
+        return jsonParser(req, res, next);
+    }, async (req, res) => {
+        try {
+            const userId = readUserId(req);
+            if (req.query.mode === 'managed') {
+                await handleManagedPut(req, res, opts.service, userId, opts.managedUploadMaxBytes);
+                return;
+            }
+            await handlePointerPut(req, res, opts.service, userId);
+        }
+        catch (err) {
+            if (handleStorageError(res, err))
+                return;
+            handleRouteError(res, 'POST /v1/storage/artifacts', err);
+        }
+    });
+}
+async function handlePointerPut(req, res, service, userId) {
+    // Project-and-validate the pointer body through the strict schema
+    // BEFORE persistence: this catches negative / fractional
+    // `size_bytes`, empty `uri` / `content_type`, and unknown keys —
+    // all of which would otherwise either insert a bad row or fail
+    // the response-shape validation after the row was already stored.
+    const parsed = PutPointerBodySchema.safeParse(req.body);
+    if (!parsed.success) {
+        res.status(400).json({
+            error_code: 'invalid_pointer_body',
+            error: 'pointer-mode body failed validation',
+            issues: parsed.error.issues.map((i) => ({ path: i.path, message: i.message })),
+        });
+        return;
+    }
+    // Re-validate metadata for the 4 KiB cap — `PutPointerBodySchema`
+    // bounds the value types but the byte-size check is policy that
+    // lives on the service-shared validator.
+    validateArtifactMetadata(parsed.data.metadata);
+    const row = await service.putPointer({
+        userId,
+        uri: parsed.data.uri,
+        contentType: parsed.data.content_type,
+        sizeBytes: parsed.data.size_bytes ?? null,
+        contentHash: parsed.data.content_hash ?? null,
+        metadata: parsed.data.metadata,
+    });
+    res.status(201).json(formatStoredArtifact(row));
+}
+async function handleManagedPut(req, res, service, userId, maxBytes) {
+    const lengthCheck = checkManagedContentLength(req, maxBytes);
+    if (lengthCheck !== null) {
+        res.status(lengthCheck.status).json({ error: lengthCheck.error });
+        return;
+    }
+    const disclose = parseDiscloseFlag(req.query.disclose_content_hash);
+    if (disclose === 'invalid') {
+        res.status(400).json({
+            error_code: 'invalid_disclose_content_hash',
+            error: 'disclose_content_hash query parameter must be "true" or "false"',
+        });
+        return;
+    }
+    const body = req.body;
+    if (!Buffer.isBuffer(body) || body.length === 0) {
+        res.status(400).json({ error: 'request body is required' });
+        return;
+    }
+    const row = await service.putManaged({
+        userId,
+        body,
+        contentType: readManagedContentType(req),
+        discloseContentHash: disclose,
+        metadata: parseMetadataHeader(req),
+    });
+    res.status(201).json(formatStoredArtifact(row));
+}
+/**
+ * Parse the `disclose_content_hash` query value with a closed
+ * tri-state result: `true`, `false`, or `'invalid'`. The route maps
+ * `'invalid'` to a 400 envelope so an unexpected value cannot
+ * silently default to `false` (which would suppress
+ * `content_hash` on the response without the caller realising).
+ */
+function parseDiscloseFlag(value) {
+    if (value === undefined)
+        return false;
+    if (value === 'true')
+        return true;
+    if (value === 'false')
+        return false;
+    return 'invalid';
+}
+function checkManagedContentLength(req, maxBytes) {
+    const header = req.headers['content-length'];
+    if (typeof header !== 'string') {
+        return { status: 411, error: 'Content-Length is required for managed uploads' };
+    }
+    const value = Number(header);
+    if (!Number.isFinite(value) || value <= 0) {
+        return { status: 411, error: 'Content-Length must be a positive integer' };
+    }
+    if (value > maxBytes) {
+        return { status: 413, error: `request body exceeds ${maxBytes}-byte cap` };
+    }
+    return null;
+}
+function readManagedContentType(req) {
+    const ct = req.headers['content-type'];
+    if (typeof ct === 'string' && ct.length > 0)
+        return ct;
+    return 'application/octet-stream';
+}
+function parseMetadataHeader(req) {
+    const raw = req.headers[METADATA_HEADER];
+    if (raw === undefined)
+        return {};
+    if (typeof raw !== 'string') {
+        throw new InvalidArtifactMetadataError('header X-AtomicMemory-Metadata must be a single header value');
+    }
+    if (Buffer.byteLength(raw, 'utf8') > METADATA_HEADER_MAX_ENCODED_BYTES) {
+        throw new InvalidArtifactMetadataError(`header X-AtomicMemory-Metadata exceeds ${METADATA_HEADER_MAX_ENCODED_BYTES}-byte encoded cap`);
+    }
+    let decoded;
+    try {
+        decoded = Buffer.from(raw, 'base64').toString('utf8');
+    }
+    catch {
+        throw new InvalidArtifactMetadataError('header X-AtomicMemory-Metadata is not valid base64');
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(decoded);
+    }
+    catch {
+        throw new InvalidArtifactMetadataError('header X-AtomicMemory-Metadata payload is not valid JSON');
+    }
+    // The inner validator throws plain `invalid_metadata`-shaped errors;
+    // rewrap to preserve the header-mode classification.
+    try {
+        return validateArtifactMetadata(parsed);
+    }
+    catch (err) {
+        if (err instanceof InvalidArtifactMetadataError) {
+            throw new InvalidArtifactMetadataError(`header X-AtomicMemory-Metadata: ${err.reason}`);
+        }
+        throw err;
+    }
+}
+function readArtifactId(req) {
+    return req.params.id;
+}
+function registerGetArtifactRoute(router, service) {
+    router.get('/artifacts/:id', async (req, res) => {
+        try {
+            const row = await service.getArtifactMetadata(readUserId(req), readArtifactId(req));
+            res.json(formatStoredArtifact(row));
+        }
+        catch (err) {
+            if (handleStorageError(res, err))
+                return;
+            handleRouteError(res, 'GET /v1/storage/artifacts/:id', err);
+        }
+    });
+}
+function registerGetArtifactContentRoute(router, service) {
+    router.get('/artifacts/:id/content', async (req, res) => {
+        try {
+            const { row, body } = await service.getArtifactContent(readUserId(req), readArtifactId(req));
+            res.setHeader('Content-Type', row.contentType ?? 'application/octet-stream');
+            res.setHeader('Content-Length', body.length.toString());
+            res.status(200).end(body);
+        }
+        catch (err) {
+            if (handleStorageError(res, err))
+                return;
+            handleRouteError(res, 'GET /v1/storage/artifacts/:id/content', err);
+        }
+    });
+}
+function registerHeadArtifactRoute(router, service) {
+    router.head('/artifacts/:id', async (req, res) => {
+        try {
+            const row = await service.getArtifactMetadata(readUserId(req), readArtifactId(req));
+            const headers = formatArtifactHeadHeaders(row);
+            res.setHeader('Content-Type', headers.contentType);
+            res.setHeader('Content-Length', headers.contentLength.toString());
+            res.setHeader('X-AtomicMemory-Artifact-Id', headers.artifactId);
+            res.setHeader('X-AtomicMemory-Storage-Mode', headers.storageMode);
+            res.setHeader('X-AtomicMemory-Storage-Status', headers.storageStatus);
+            res.setHeader('X-AtomicMemory-Provider', headers.provider);
+            res.status(200).end();
+        }
+        catch (err) {
+            if (err instanceof StorageArtifactNotFoundError) {
+                res.status(404).end();
+                return;
+            }
+            handleRouteError(res, 'HEAD /v1/storage/artifacts/:id', err);
+        }
+    });
+}
+function registerDeleteArtifactRoute(router, service) {
+    router.delete('/artifacts/:id', async (req, res) => {
+        try {
+            if ('force' in req.query) {
+                // Any presence of `force` (bare `?force`, `?force=true`,
+                // `?force=false`, multi-value) is rejected with a stable
+                // typed envelope. Silently coercing to `policy=artifact_only`
+                // would mask a caller bug: pre-Step-5 deployments accepted
+                // `?force=true` to bypass the reference gate; the new
+                // contract requires explicit `policy=with_documents`.
+                res.status(400).json({
+                    error_code: 'force_not_supported',
+                    error: 'force is not a supported parameter; use policy=with_documents to cascade',
+                });
+                return;
+            }
+            const policyRaw = String(req.query.policy ?? 'artifact_only');
+            if (policyRaw !== 'artifact_only' && policyRaw !== 'with_documents') {
+                res.status(400).json({
+                    error_code: 'invalid_policy',
+                    error: "policy must be 'artifact_only' or 'with_documents'",
+                });
+                return;
+            }
+            const result = await service.deleteArtifact({
+                userId: readUserId(req),
+                id: readArtifactId(req),
+                policy: policyRaw,
+            });
+            res.status(200).json({
+                artifact_id: result.artifact.id,
+                status: result.artifact.status === 'deleted' ? 'deleted' : 'delete_failed',
+                ...(result.cascadedDocumentIds.length > 0
+                    ? { cascaded_document_ids: result.cascadedDocumentIds }
+                    : {}),
+            });
+        }
+        catch (err) {
+            if (handleStorageError(res, err))
+                return;
+            handleRouteError(res, 'DELETE /v1/storage/artifacts/:id', err);
+        }
+    });
+}
+function registerVerifyArtifactRoute(router, service) {
+    router.post('/artifacts/:id/verify', async (req, res) => {
+        try {
+            const id = readArtifactId(req);
+            const result = await service.verifyArtifact(readUserId(req), id);
+            res.status(200).json({
+                artifact_id: id,
+                kind: result.kind,
+                ...(result.kind === 'verified'
+                    ? { details: result.details ?? {} }
+                    : { reason: result.reason }),
+            });
+        }
+        catch (err) {
+            if (handleStorageError(res, err))
+                return;
+            handleRouteError(res, 'POST /v1/storage/artifacts/:id/verify', err);
+        }
+    });
+}
+const USER_ID_HEADER = 'x-atomicmemory-user-id';
+/**
+ * Owner scope for every direct-storage call comes from the
+ * `X-AtomicMemory-User-Id` request header. The legacy `?user_id=`
+ * query and body `user_id` field are explicitly rejected — sending
+ * identity in URLs leaks into proxy/CDN/error-tracker logs, and
+ * body assertion would silently survive a path migration.
+ *
+ * The `Authorization: Bearer <CORE_API_KEY>` middleware already ran
+ * upstream (`requireBearer`); this function only resolves which user
+ * the validated caller is acting on behalf of.
+ */
+function readUserId(req) {
+    if (hasLegacyUserId(req)) {
+        throw new LegacyUserIdRejection();
+    }
+    const fromHeader = req.headers[USER_ID_HEADER];
+    if (typeof fromHeader === 'string' && fromHeader.length > 0)
+        return fromHeader;
+    throw new InvalidArtifactMetadataError('X-AtomicMemory-User-Id header is required');
+}
+function hasLegacyUserId(req) {
+    if (typeof req.query.user_id === 'string' && req.query.user_id.length > 0) {
+        return true;
+    }
+    if (req.body && typeof req.body === 'object') {
+        const candidate = req.body.user_id;
+        if (typeof candidate === 'string' && candidate.length > 0)
+            return true;
+    }
+    return false;
+}

package/dist/routes/upstream-provider-errors.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Upstream AI provider error classification for HTTP routes.
+ *
+ * Provider SDKs expose slightly different error classes, but they
+ * consistently carry an HTTP-ish `status` plus message text. This
+ * module converts those raw SDK failures into a small sanitized
+ * envelope for route handlers without coupling routes to one vendor.
+ */
+export interface UpstreamProviderFailure {
+    status: number;
+    errorCode: string;
+    error: string;
+    message: string;
+    providerStatus: number;
+    retryable: boolean;
+    details: string;
+}
+export declare function classifyUpstreamProviderFailure(err: unknown): UpstreamProviderFailure | null;
+export declare function routeErrorMessage(err: unknown): string;

package/dist/routes/upstream-provider-errors.js

@@ -0,0 +1,95 @@
+/**
+ * Upstream AI provider error classification for HTTP routes.
+ *
+ * Provider SDKs expose slightly different error classes, but they
+ * consistently carry an HTTP-ish `status` plus message text. This
+ * module converts those raw SDK failures into a small sanitized
+ * envelope for route handlers without coupling routes to one vendor.
+ */
+export function classifyUpstreamProviderFailure(err) {
+    const providerStatus = readProviderStatus(err);
+    if (providerStatus === null || !looksLikeProviderError(err, providerStatus))
+        return null;
+    const details = sanitizeProviderDetails(errorMessage(err));
+    if (providerStatus === 429 && isQuotaFailure(details)) {
+        return providerFailure('upstream_provider_quota_exceeded', 503, providerStatus, false, details);
+    }
+    if (providerStatus === 429) {
+        return providerFailure('upstream_provider_rate_limited', 503, providerStatus, true, details);
+    }
+    if (providerStatus === 401 || providerStatus === 403) {
+        return providerFailure('upstream_provider_auth_failed', 502, providerStatus, false, details);
+    }
+    return providerFailure('upstream_provider_error', providerStatus >= 500 ? 503 : 502, providerStatus, providerStatus >= 500, details);
+}
+export function routeErrorMessage(err) {
+    return err instanceof Error ? err.message : String(err ?? 'Internal server error');
+}
+function providerFailure(errorCode, status, providerStatus, retryable, details) {
+    const messages = providerFailureMessages(errorCode);
+    return { status, errorCode, providerStatus, retryable, details, ...messages };
+}
+function providerFailureMessages(errorCode) {
+    if (errorCode === 'upstream_provider_quota_exceeded')
+        return quotaMessage();
+    if (errorCode === 'upstream_provider_rate_limited')
+        return rateLimitMessage();
+    if (errorCode === 'upstream_provider_auth_failed')
+        return authFailureMessage();
+    return {
+        error: 'Upstream provider request failed',
+        message: 'The configured AI provider rejected the request. Check provider configuration and provider status.',
+    };
+}
+function quotaMessage() {
+    return {
+        error: 'Upstream provider quota exceeded',
+        message: 'The configured AI provider rejected the request because its account quota or billing is unavailable.',
+    };
+}
+function rateLimitMessage() {
+    return {
+        error: 'Upstream provider rate limited',
+        message: 'The configured AI provider rate-limited the request. Retry after the provider limit resets.',
+    };
+}
+function authFailureMessage() {
+    return {
+        error: 'Upstream provider authentication failed',
+        message: 'The configured AI provider rejected the request credentials. Check the provider API key and account access.',
+    };
+}
+function readProviderStatus(err) {
+    if (!err || typeof err !== 'object' || !('status' in err))
+        return null;
+    const status = err.status;
+    return typeof status === 'number' && Number.isInteger(status) ? status : null;
+}
+function looksLikeProviderError(err, status) {
+    const message = routeErrorMessage(err).toLowerCase();
+    if (status === 401 || status === 403 || status === 429 || status >= 500) {
+        return hasProviderErrorShape(err) || hasProviderKeyword(message);
+    }
+    return hasProviderErrorShape(err) && status >= 400;
+}
+function hasProviderErrorShape(err) {
+    if (!err || typeof err !== 'object')
+        return false;
+    const candidate = err;
+    return 'headers' in candidate || 'request_id' in candidate || 'code' in candidate || 'type' in candidate;
+}
+function hasProviderKeyword(message) {
+    return /\b(openai|anthropic|ollama|voyage|google|gemini|groq|provider|llm|embedding|embed|api key|quota|billing|rate limit)\b/.test(message);
+}
+function isQuotaFailure(details) {
+    return /\b(quota|billing|insufficient_quota|credits?)\b/i.test(details);
+}
+function errorMessage(err) {
+    return routeErrorMessage(err);
+}
+function sanitizeProviderDetails(message) {
+    return message
+        .replace(/sk-[A-Za-z0-9_-]{8,}/g, '[REDACTED_API_KEY]')
+        .replace(/Bearer\s+[A-Za-z0-9._~+/=-]{8,}/gi, 'Bearer [REDACTED_TOKEN]')
+        .slice(0, 500);
+}

package/dist/schemas/agents.d.ts

@@ -0,0 +1,79 @@
+/**
+ * @file Zod schemas for the 5 /v1/agents/* routes.
+ *
+ * Mirrors the inline parsers at `src/routes/agents.ts:86-109`
+ * byte-for-byte:
+ *   - `requireString` accepts either a string OR an array (takes
+ *     first element via `String(value[0])`) — this handles Express
+ *     query strings with duplicate params. Throws
+ *     `"${field} is required"` on missing/non-accepted input.
+ *   - `requireTrustLevel` distinguishes type error ("trust_level must
+ *     be a number between 0.0 and 1.0") from range error
+ *     ("trust_level must be between 0.0 and 1.0").
+ *   - `requireResolution` accepts the three enum variants; anything
+ *     else throws the full list-of-valid-values message.
+ *
+ * Every error message matches the pre-refactor text exactly so HTTP
+ * clients that regex on `{ error }` continue to match.
+ */
+import { z } from './zod-setup.js';
+export declare const SetTrustBodySchema: z.ZodPipe<z.ZodObject<{
+    agent_id: z.ZodPipe<z.ZodPipe<z.ZodUnknown, z.ZodTransform<string | undefined, unknown>> & z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>, z.ZodTransform<string, string>>;
+    user_id: z.ZodPipe<z.ZodPipe<z.ZodUnknown, z.ZodTransform<string | undefined, unknown>> & z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>, z.ZodTransform<string, string>>;
+    trust_level: z.ZodPipe<z.ZodUnknown, z.ZodTransform<number, unknown>>;
+    display_name: z.ZodPipe<z.ZodUnknown, z.ZodTransform<string | undefined, unknown>>;
+}, z.core.$strip>, z.ZodTransform<{
+    agentId: string;
+    userId: string;
+    trustLevel: number;
+    displayName: string | undefined;
+}, {
+    agent_id: string;
+    user_id: string;
+    trust_level: number;
+    display_name: string | undefined;
+}>>;
+export type SetTrustBody = z.infer<typeof SetTrustBodySchema>;
+export declare const GetTrustQuerySchema: z.ZodPipe<z.ZodObject<{
+    agent_id: z.ZodPipe<z.ZodPipe<z.ZodUnknown, z.ZodTransform<string | undefined, unknown>> & z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>, z.ZodTransform<string, string>>;
+    user_id: z.ZodPipe<z.ZodPipe<z.ZodUnknown, z.ZodTransform<string | undefined, unknown>> & z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>, z.ZodTransform<string, string>>;
+}, z.core.$strip>, z.ZodTransform<{
+    agentId: string;
+    userId: string;
+}, {
+    agent_id: string;
+    user_id: string;
+}>>;
+export type GetTrustQuery = z.infer<typeof GetTrustQuerySchema>;
+export declare const UserIdFromQuerySchema: z.ZodPipe<z.ZodObject<{
+    user_id: z.ZodPipe<z.ZodPipe<z.ZodUnknown, z.ZodTransform<string | undefined, unknown>> & z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>, z.ZodTransform<string, string>>;
+}, z.core.$strip>, z.ZodTransform<{
+    userId: string;
+}, {
+    user_id: string;
+}>>;
+export type UserIdFromQuery = z.infer<typeof UserIdFromQuerySchema>;
+export declare const UserIdFromBodySchema: z.ZodPipe<z.ZodObject<{
+    user_id: z.ZodPipe<z.ZodPipe<z.ZodUnknown, z.ZodTransform<string | undefined, unknown>> & z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>, z.ZodTransform<string, string>>;
+}, z.core.$strip>, z.ZodTransform<{
+    userId: string;
+}, {
+    user_id: string;
+}>>;
+export type UserIdFromBody = z.infer<typeof UserIdFromBodySchema>;
+export declare const ConflictIdParamSchema: z.ZodPipe<z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>, z.ZodTransform<{
+    id: string;
+}, {
+    id: string;
+}>>;
+export type ConflictIdParam = z.infer<typeof ConflictIdParamSchema>;
+export declare const ResolveConflictBodySchema: z.ZodPipe<z.ZodObject<{
+    resolution: z.ZodPipe<z.ZodUnknown & z.ZodType<"resolved_new" | "resolved_existing" | "resolved_both", unknown, z.core.$ZodTypeInternals<"resolved_new" | "resolved_existing" | "resolved_both", unknown>>, z.ZodTransform<"resolved_new" | "resolved_existing" | "resolved_both", "resolved_new" | "resolved_existing" | "resolved_both">>;
+}, z.core.$strip>, z.ZodTransform<{
+    resolution: "resolved_new" | "resolved_existing" | "resolved_both";
+}, {
+    resolution: "resolved_new" | "resolved_existing" | "resolved_both";
+}>>;
+export type ResolveConflictBody = z.infer<typeof ResolveConflictBodySchema>;