maka-agent 0.2.0-dev.3.20260830 → 0.2.0-dev.31.20260913

package/node_modules/@maka/core/dist/llm-connections.js

@@ -17,11 +17,15 @@
  * under the License.
  */
 import { CODEX_SUBSCRIPTION_UNSUPPORTED_CHATGPT_MODELS } from './codex-model-compatibility.js';
-import { CATALOG_PROVIDER_TYPES, OPENCODE_FREE_DEFAULT_ENABLED_MODELS, OPENCODE_FREE_DEFAULT_MODEL, PROVIDER_REGISTRY, READY_PROVIDER_TYPES, RECOMMENDED_PROVIDER_TYPES, } from './provider-registry.js';
+import { CATALOG_PROVIDER_TYPES, OPENCODE_FREE_DEFAULT_MODEL, PROVIDER_REGISTRY, RECOMMENDED_PROVIDER_TYPES, providerDefaultsOf, providerFallbackModelIds, providerMenuLabel, } from './provider-registry.js';
 export { CODEX_SUBSCRIPTION_UNSUPPORTED_CHATGPT_MODELS };
-export { CATALOG_PROVIDER_TYPES, OPENCODE_FREE_DEFAULT_ENABLED_MODELS, OPENCODE_FREE_DEFAULT_MODEL, PROVIDER_REGISTRY, READY_PROVIDER_TYPES, RECOMMENDED_PROVIDER_TYPES, };
+export { CATALOG_PROVIDER_TYPES, OPENCODE_FREE_DEFAULT_MODEL, PROVIDER_REGISTRY, RECOMMENDED_PROVIDER_TYPES, providerDefaultsOf, providerFallbackModelIds, providerMenuLabel, };
 export function isRelayProviderType(providerType) {
-    return PROVIDER_REGISTRY[providerType].relayModelProfiles === true;
+    return providerType === 'openai-compatible' || providerType === 'openai-responses-compatible';
+}
+const MODEL_MODALITIES = ['text', 'image', 'audio', 'pdf', 'video'];
+export function isModelModality(value) {
+    return MODEL_MODALITIES.includes(value);
 }
 /**
  * Read-time normalizer: the model ids a stored connection exposes.
@@ -48,12 +52,57 @@ export function connectionEnabledModelIds(connection) {
     }
     return [...seen];
 }
-export function classifyConnectionModelInventory(connection) {
-    if (connection.models === undefined || connection.modelSource === undefined)
-        return 'absent';
-    if (!providerSupportsModelDiscovery(connection.providerType))
-        return 'snapshot';
-    return connection.modelSource === 'fetched' ? 'live' : 'snapshot';
+/**
+ * The models this connection offers a user to pick, as the Host decided them.
+ *
+ * The one answer to "may this model be offered". Every picker — chat, daily
+ * review, the TUI, subagent presets — asks here, so a Desktop and a TUI
+ * attached to one Host cannot disagree about what is selectable. Three facts
+ * decide it and all three are the Host's:
+ *
+ *   1. the connection is enabled and its provider is one this build registers;
+ *   2. the user enabled this model on it;
+ *   3. the Host's entry says the connection can hold a chat on it.
+ *
+ * (3) already subsumes what clients used to re-derive locally: a retired
+ * provider, a quarantined `brokenModelIds` id, and a model whose metadata says
+ * it cannot chat are all non-offerable before a client sees them. A client
+ * re-testing any of those against its OWN registry answers for a build that is
+ * not the one running the send.
+ *
+ * A saved selection that is no longer offered is deliberately absent rather
+ * than filtered late: callers that must keep the current value visible append
+ * it themselves with an "unavailable" label, which says the true thing.
+ *
+ * The Codex subscription's servable set needs no filter here either: the Host
+ * resolved these entries through `normalizeOpenAiCodexConnection`, so an id
+ * that subscription cannot serve never became an entry to intersect with.
+ */
+export function offerableCatalogEntries(connection) {
+    if (!connection.enabled || !providerDefaultsOf(connection.providerType))
+        return [];
+    const enabled = new Set(connectionEnabledModelIds(connection));
+    return connection.catalogEntries.filter((entry) => entry.canUseAsChatDefault && enabled.has(entry.id));
+}
+/**
+ * Whether `connection.models` is this account's own list, as a provider
+ * enumerated it — the one question anything asks about that array's provenance.
+ *
+ * It is a conjunction, not a reading of `modelSource` alone. `'fetched'` means
+ * a discovery run wrote this row, and for a provider whose
+ * `modelDiscovery.kind` is `'fallback'` that run replays the array this build
+ * shipped: accurate, and still a snapshot of the provider at release rather
+ * than of the account. Absence from a snapshot means nothing at all (#1584),
+ * and a connection can be created and used before any run at all (#2896) — so
+ * only a discovering provider that has actually run answers true here.
+ *
+ * This describes a catalog; it never decides what a connection may run — see
+ * `authorizeConnectionModel`.
+ */
+export function connectionModelsEnumerateAccount(connection) {
+    return (connection.modelSource === 'fetched' &&
+        connection.models !== undefined &&
+        providerSupportsModelDiscovery(connection.providerType));
 }
 /**
  * The model this connection runs for this id, or `undefined` if the user never
@@ -74,9 +123,9 @@ export function classifyConnectionModelInventory(connection) {
  * (#2896). Guessing wrong costs one failed request with the provider's own
  * error on it.
  *
- * `classifyConnectionModelInventory` still says whether a catalog could have
- * seen the model, and the picker uses that to annotate one the provider did
- * not mention. Annotating is not vetoing.
+ * `connectionModelsEnumerateAccount` still says whether a catalog could have
+ * seen the model, which is a fact worth acting on elsewhere. Acting on it is
+ * not vetoing.
  */
 export function authorizeConnectionModel(connection, modelId) {
     const model = modelId.trim();
@@ -85,7 +134,7 @@ export function authorizeConnectionModel(connection, modelId) {
     // The one veto: quarantined ids fail in a shape the send cannot surface
     // (e.g. a billed 200 with an empty completion), so the request settling it
     // is not available as the arbiter. See ProviderDefaults.brokenModelIds.
-    if (PROVIDER_DEFAULTS[connection.providerType]?.brokenModelIds?.includes(model)) {
+    if (providerDefaultsOf(connection.providerType)?.brokenModelIds?.includes(model)) {
         return undefined;
     }
     // The observed row wins wherever it exists: it carries wire metadata such as
@@ -179,6 +228,19 @@ export function reconcileConnectionAfterModelFetch(connection, models, options)
     const previousEnabled = [
         ...new Set(connectionEnabledModelIds(connection).map((id) => supersededModelId(id, live, options?.aliases))),
     ];
+    if (options?.authoritative) {
+        // The first account-scoped fetch replaces the provider fallback guess: no
+        // user chose those bootstrap ids, and every usable model should be offered.
+        // Later refreshes preserve explicit user choices only while they remain in
+        // the account catalog; newly introduced models stay opt-in.
+        const enabledModelIds = connection.hasModelInventory
+            ? previousEnabled.filter((id) => live.has(id))
+            : liveIds;
+        const defaultModel = enabledModelIds.includes(previousDefault)
+            ? previousDefault
+            : (enabledModelIds[0] ?? '');
+        return { defaultModel, enabledModelIds };
+    }
     // Seed a first choice only for a connection that has never had a list to
     // pick from: four providers ship no `fallbackModels`, so for them discovery
     // is the only place a first default can come from.
@@ -202,87 +264,42 @@ export function reconcileConnectionAfterModelFetch(connection, models, options)
         }),
     };
 }
-export const PROVIDER_DEFAULTS = PROVIDER_REGISTRY;
 /**
- * The registry entry for a provider, or `undefined` when this build does not
- * register one.
- *
- * Sole owner of the question "is this `providerType` one we know". Plain
- * indexing cannot answer it: `PROVIDER_DEFAULTS` is an object literal, so
- * `PROVIDER_DEFAULTS['__proto__']` and `['toString']` resolve to inherited
- * members and read as registered providers. Every recognition site goes
- * through here rather than repeating the own-property check.
+ * The models a connection created without an explicit selection starts with,
+ * or undefined when the provider seeds nothing. Derived from the provider's
+ * shipped baseline rather than listed a second time: the two can then never
+ * disagree about what "all of them" means.
  */
-export function providerDefaultsOf(providerType) {
-    return Object.hasOwn(PROVIDER_DEFAULTS, providerType)
-        ? PROVIDER_DEFAULTS[providerType]
-        : undefined;
-}
 export function defaultEnabledModelIdsWhenOmitted(providerType) {
-    return PROVIDER_DEFAULTS[providerType].defaultEnabledModelIds;
+    const defaults = providerDefaultsOf(providerType);
+    if (!defaults?.enableShippedModelsByDefault)
+        return undefined;
+    return providerFallbackModelIds(defaults);
 }
 export function providerAuthRequiresSecret(providerType) {
-    const authKind = PROVIDER_DEFAULTS[providerType]?.authKind;
+    const authKind = providerDefaultsOf(providerType)?.authKind;
     return authKind === 'api_key' || authKind === 'oauth_token';
 }
 export function providerAuthSupportsApiKey(providerType) {
-    const authKind = PROVIDER_DEFAULTS[providerType]?.authKind;
+    const authKind = providerDefaultsOf(providerType)?.authKind;
     return authKind === 'api_key' || authKind === 'optional_api_key';
 }
 export function providerSupportsModelDiscovery(providerType) {
-    const discovery = PROVIDER_DEFAULTS[providerType]?.modelDiscovery;
+    const discovery = providerDefaultsOf(providerType)?.modelDiscovery;
     return discovery !== undefined && discovery.kind !== 'fallback';
 }
-/**
- * The backend that runs a connection.
- *
- * Throws for an unknown `providerType` (a legacy seed, or a connection
- * persisted on a branch that registers a provider this build doesn't know).
- * It used to answer `'fake'` there, which was the last live producer of that
- * value (#3211); there is no honest backend to name for a provider this build
- * cannot describe. Callers that need a non-throwing answer are asking whether
- * the connection is usable, not which backend runs it — use `isRealConnection`
- * / `isConnectionReady` from `connection-readiness.ts`.
- */
-export function backendKindOf(c) {
-    const defaults = providerDefaultsOf(c.providerType);
-    if (!defaults)
-        throw new Error(`Unknown providerType: ${c.providerType}`);
-    return defaults.backendKind;
-}
 export function effectiveBaseUrl(c) {
     if (c.baseUrl && c.baseUrl.trim())
         return c.baseUrl.trim();
-    return PROVIDER_DEFAULTS[c.providerType]?.baseUrl ?? '';
-}
-/**
- * Reduce a submitted connection `baseUrl` to the value that should be persisted,
- * or `undefined` if nothing should be stored.
- *
- * The add-form and edit-form pre-fill `defaults.baseUrl` and submit it verbatim
- * when the user does not customize the field. Storing that default as an
- * explicit override would pin the connection to the current default —
- * `effectiveBaseUrl` honors the explicit value first, so future default changes
- * would not reach it. Only a real override (non-empty and differing from the
- * current default) is persisted; the empty/whitespace and equals-default cases
- * collapse to `undefined` so the connection reads back through the live default.
- */
-export function persistedBaseUrl(providerType, baseUrl) {
-    const trimmed = baseUrl?.trim();
-    if (!trimmed)
-        return undefined;
-    if (trimmed === PROVIDER_DEFAULTS[providerType]?.baseUrl)
-        return undefined;
-    return trimmed;
+    return providerDefaultsOf(c.providerType)?.baseUrl ?? '';
 }
 export function validateSlug(slug) {
     if (!slug.trim())
-        return 'Slug is required';
-    if (!/^[a-z0-9][a-z0-9-]*[a-z0-9]$/.test(slug)) {
-        return 'Slug must be lowercase letters, digits, and hyphens';
-    }
+        return 'required';
+    if (!/^[a-z0-9][a-z0-9-]*[a-z0-9]$/.test(slug))
+        return 'format';
     if (slug.length > 64)
-        return 'Slug must be 64 characters or fewer';
+        return 'too_long';
     return null;
 }
 /** Derive an unused connection slug from a catalog provider type. */
@@ -296,6 +313,30 @@ export function deriveConnectionSlug(providerType, existingSlugs = []) {
             return candidate;
     }
 }
+/** Stable human-facing slug base for one interactive OAuth Connection. */
+function interactiveOAuthConnectionSlugBase(providerType) {
+    switch (providerType) {
+        case 'openai-codex':
+            return 'codex-subscription';
+        case 'xai-oauth':
+            return 'xai-oauth';
+        // Shared with the local `gh` credential import so both routes to a Copilot
+        // account land on one Connection instead of two.
+        case 'github-copilot':
+            return 'github-copilot';
+    }
+}
+/** Derive an unused OAuth Connection slug without moving allocation into a surface. */
+export function deriveInteractiveOAuthConnectionSlug(providerType, existingSlugs = []) {
+    const base = interactiveOAuthConnectionSlugBase(providerType);
+    if (!existingSlugs.includes(base))
+        return base;
+    for (let suffix = 2;; suffix += 1) {
+        const candidate = `${base}-${suffix}`;
+        if (!existingSlugs.includes(candidate))
+            return candidate;
+    }
+}
 /**
  * PR-UI-IPC-1 (@kenji msg 35260e29 + 2e495eb7): connection `baseUrl`
  * scheme allowlist gate.
@@ -434,16 +475,3 @@ export function normalizeConnectionBaseUrl(baseUrl) {
     // convert this to `undefined` — see contract note above.
     return { ok: true, value: baseUrl.trim() };
 }
-export function normalizePersistedConnection(input) {
-    if (!input || typeof input !== 'object' || Array.isArray(input)) {
-        throw new Error('Invalid connection: expected an object');
-    }
-    const value = input;
-    if (typeof value.providerType !== 'string' || !value.providerType) {
-        throw new Error('Invalid connection: providerType is required');
-    }
-    return {
-        ...value,
-        enabledModelIds: connectionEnabledModelIds(value),
-    };
-}

package/node_modules/@maka/core/dist/local-memory.js

@@ -17,6 +17,7 @@
  * under the License.
  */
 import { redactSecrets } from './redaction.js';
+import { truncateUtf16Safe } from './text-sanitize.js';
 export const LOCAL_MEMORY_MAX_BYTES = 128 * 1024;
 export const LOCAL_MEMORY_PROMPT_MAX_CHARS = 12_000;
 export const LOCAL_MEMORY_PROMPT_TRUNCATION_MARKER = '[本地记忆已按长度截断]';
@@ -69,8 +70,7 @@ export function buildLocalMemoryPromptBody(input, context = {}) {
         return undefined;
     if (body.length <= LOCAL_MEMORY_PROMPT_MAX_CHARS)
         return body;
-    const truncated = body.slice(0, LOCAL_MEMORY_PROMPT_MAX_CHARS);
-    const boundarySafe = /[\uD800-\uDBFF]$/.test(truncated) ? truncated.slice(0, -1) : truncated;
+    const boundarySafe = truncateUtf16Safe(body, LOCAL_MEMORY_PROMPT_MAX_CHARS);
     return `${boundarySafe.trimEnd()}\n\n${LOCAL_MEMORY_PROMPT_TRUNCATION_MARKER}`;
 }
 export function appendManualLocalMemoryEntryDraft(currentDraft, input) {

package/node_modules/@maka/core/dist/maka-wordmark.js

@@ -0,0 +1,23 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+/**
+ * Traced outline of Maka's product wordmark in its canonical 460×120 view box.
+ * Renderers choose color through `currentColor`; the brand geometry has one owner.
+ */
+export const MAKA_WORDMARK_PATH = 'M2639 1187 c-38 -29 -39 -46 -39 -479 0 -400 1 -425 19 -455 23 -37 68 -50 108 -31 41 20 53 53 53 154 0 83 2 92 25 114 l24 23 143 -138 c79 -75 156 -143 171 -151 57 -30 127 14 127 79 0 32 -39 75 -217 238 l-82 75 130 103 c157 125 173 152 123 210 -21 25 -34 31 -65 31 -35 0 -55 -13 -209 -140 l-170 -139 0 229 0 228 -26 31 c-20 24 -34 31 -62 31 -21 0 -44 -6 -53 -13z M1926 969 c-109 -26 -216 -114 -264 -217 -24 -50 -27 -69 -27 -162 0 -95 3 -111 28 -162 39 -79 104 -143 185 -181 62 -29 75 -32 168 -32 94 0 105 2 164 33 35 18 64 31 64 30 18 -50 63 -74 111 -58 57 19 60 32 57 258 -2 176 -6 211 -23 258 -24 63 -100 151 -163 188 -84 49 -205 67 -300 45z m142 -170 c93 -20 171 -113 172 -205 0 -58 -45 -140 -97 -177 -112 -80 -278 -26 -328 107 -43 112 34 247 158 276 45 11 41 11 95 -1z M547 960 c-105 -18 -200 -90 -248 -187 -23 -45 -24 -60 -27 -268 -2 -120 -1 -229 3 -242 7 -30 58 -56 94 -48 16 3 38 16 49 28 19 20 21 36 24 227 3 226 8 248 69 290 69 50 157 44 215 -14 46 -46 54 -88 54 -297 0 -179 1 -186 23 -207 43 -40 100 -37 134 7 9 11 12 71 13 201 0 102 5 202 10 222 32 114 172 160 264 87 55 -44 60 -66 61 -284 1 -110 5 -208 9 -218 13 -27 63 -49 97 -42 16 4 38 18 49 32 19 24 20 40 20 228 0 224 -8 268 -61 348 -60 90 -158 139 -280 139 -62 1 -88 -4 -135 -26 -33 -15 -71 -38 -85 -52 l-27 -26 -50 36 c-82 60 -179 83 -275 66z M3659 960 c-137 -23 -264 -138 -299 -268 -53 -202 61 -407 260 -466 102 -30 242 -14 304 35 15 12 28 20 29 18 1 -2 7 -13 13 -24 26 -48 94 -55 135 -14 19 19 20 30 17 237 -3 214 -3 218 -31 273 -50 103 -163 186 -282 208 -65 12 -79 12 -146 1z m114 -201 c33 -65 48 -81 107 -112 59 -31 61 -49 10 -72 -52 -24 -93 -70 -115 -131 -10 -27 -24 -56 -32 -64 -11 -12 -15 -12 -26 0 -8 8 -19 35 -26 59 -14 48 -67 110 -121 139 -19 10 -35 25 -35 33 0 7 21 23 46 35 52 25 106 82 115 122 8 34 24 54 38 49 6 -2 23 -28 39 -58z';

package/node_modules/@maka/core/dist/model-call-attempt.js

@@ -58,6 +58,9 @@ export const MODEL_CALL_COST_BASES = ['priced', 'unpriced'];
 export const HISTORY_COMPACT_ROUTES = ['text_summary', 'provider_native'];
 /** Hard bound for provider-supplied diagnostic identifiers stored on an attempt. */
 export const MODEL_CALL_DIAGNOSTIC_FIELD_MAX_LENGTH = 256;
+export const PREPARED_REQUEST_OBSERVATION_SCHEMA_VERSION = 1;
+export const PREPARED_REQUEST_OBSERVATION_MAX_SEGMENTS = 256;
+export const PREPARED_REQUEST_OBSERVATION_TEXT_MAX_LENGTH = 256;
 const MODEL_CALL_ATTEMPT_SHAPE = defineObjectShape()([
     'schemaVersion',
     'logicalCallId',
@@ -80,8 +83,11 @@ const MODEL_CALL_ATTEMPT_SHAPE = defineObjectShape()([
 ], [
     'connectionSlug',
     'historyCompactRoute',
+    'requestCompositionId',
     'contextWindow',
     'captureArtifactId',
+    'promptComposition',
+    'requestObservation',
     'timeToFirstTokenMs',
     'finishReason',
     'errorClass',
@@ -107,6 +113,38 @@ const TOKEN_FIELDS = [
     'cacheWriteInputTokens',
     'reasoningTokens',
 ];
+const PREPARED_REQUEST_OBSERVATION_SHAPE = defineObjectShape()(['schemaVersion', 'digest', 'bytes', 'segments'], []);
+const PREPARED_REQUEST_OBSERVATION_SEGMENT_SHAPE = defineObjectShape()(['kind', 'index', 'cacheable', 'comparison', 'digest', 'bytes'], ['representedSegments', 'role', 'label']);
+const PREPARED_REQUEST_SEGMENT_KINDS = [
+    'tool_schema',
+    'system_prompt',
+    'message',
+    'provider_options',
+];
+const PROMPT_COMPOSITION_SHAPE = defineObjectShape()(['segments'], ['tools', 'remainingTools', 'unlabelledToolBytes']);
+const PROMPT_COMPOSITION_SEGMENT_SHAPE = defineObjectShape()(['kind', 'bytes'], []);
+const PROMPT_COMPOSITION_TOOL_SHAPE = defineObjectShape()(['name', 'bytes'], []);
+const PROMPT_COMPOSITION_REMAINING_TOOLS_SHAPE = defineObjectShape()(['count', 'bytes'], []);
+/**
+ * The fold's buckets, in the order a composition lists them.
+ *
+ * The order is part of the contract, not presentation: a reader comparing two
+ * compositions compares them position by position, and the projection
+ * validator rejects a record whose segments arrive out of this order.
+ */
+export const PROMPT_COMPOSITION_SEGMENT_KINDS = [
+    'system_instructions',
+    'tool_definitions',
+    'messages',
+    'other',
+];
+/**
+ * The fold names one tool per row, so the row count is what bounds this record.
+ * Generous enough for a normal registry, small enough that a pathological one
+ * cannot make an attempt unbounded. Exported because the fold that produces
+ * these rows has to cut at the same number the decoder accepts.
+ */
+export const PROMPT_COMPOSITION_MAX_TOOLS = 64;
 function isNonEmptyString(value) {
     return typeof value === 'string' && value.length > 0;
 }
@@ -129,6 +167,98 @@ function isOptionalHttpStatus(value) {
     return (value === undefined ||
         (isFiniteNumber(value) && Number.isInteger(value) && value >= 100 && value <= 599));
 }
+function isSha256Digest(value) {
+    return typeof value === 'string' && /^sha256:[a-f0-9]{64}$/.test(value);
+}
+function isOptionalBoundedText(value) {
+    return (value === undefined ||
+        (typeof value === 'string' && value.length <= PREPARED_REQUEST_OBSERVATION_TEXT_MAX_LENGTH));
+}
+function isPreparedRequestObservationSegment(value) {
+    if (!isRecord(value) || !hasExactShape(value, PREPARED_REQUEST_OBSERVATION_SEGMENT_SHAPE)) {
+        return false;
+    }
+    return (PREPARED_REQUEST_SEGMENT_KINDS.includes(value.kind) &&
+        isNonNegativeInteger(value.index) &&
+        typeof value.cacheable === 'boolean' &&
+        (value.comparison === 'exact' || value.comparison === 'opaque') &&
+        isSha256Digest(value.digest) &&
+        isNonNegativeInteger(value.bytes) &&
+        (value.representedSegments === undefined ||
+            (typeof value.representedSegments === 'number' &&
+                Number.isSafeInteger(value.representedSegments) &&
+                value.representedSegments > 0)) &&
+        (value.representedSegments === undefined || value.comparison === 'opaque') &&
+        isOptionalBoundedText(value.role) &&
+        isOptionalBoundedText(value.label));
+}
+function isPromptComposition(value) {
+    if (!isRecord(value) || !hasExactShape(value, PROMPT_COMPOSITION_SHAPE))
+        return false;
+    if (!Array.isArray(value.segments) || !value.segments.every(isPromptCompositionSegment)) {
+        return false;
+    }
+    // One kind per row: a fold that named the same bucket twice would let a
+    // reader's total disagree with the store's.
+    const kinds = value.segments.map((segment) => segment.kind);
+    if (new Set(kinds).size !== kinds.length)
+        return false;
+    if (value.tools !== undefined) {
+        if (!Array.isArray(value.tools) || value.tools.length > PROMPT_COMPOSITION_MAX_TOOLS) {
+            return false;
+        }
+        if (!value.tools.every(isPromptCompositionTool))
+            return false;
+    }
+    if (value.remainingTools !== undefined &&
+        !(isRecord(value.remainingTools) &&
+            hasExactShape(value.remainingTools, PROMPT_COMPOSITION_REMAINING_TOOLS_SHAPE) &&
+            isNonNegativeInteger(value.remainingTools.count) &&
+            isNonNegativeInteger(value.remainingTools.bytes))) {
+        return false;
+    }
+    return value.unlabelledToolBytes === undefined || isNonNegativeInteger(value.unlabelledToolBytes);
+}
+function isPromptCompositionSegment(value) {
+    return (isRecord(value) &&
+        hasExactShape(value, PROMPT_COMPOSITION_SEGMENT_SHAPE) &&
+        PROMPT_COMPOSITION_SEGMENT_KINDS.includes(value.kind) &&
+        isNonNegativeInteger(value.bytes));
+}
+function isPromptCompositionTool(value) {
+    return (isRecord(value) &&
+        hasExactShape(value, PROMPT_COMPOSITION_TOOL_SHAPE) &&
+        typeof value.name === 'string' &&
+        value.name.length <= PREPARED_REQUEST_OBSERVATION_TEXT_MAX_LENGTH &&
+        isNonNegativeInteger(value.bytes));
+}
+function isPreparedRequestObservation(value) {
+    if (!isRecord(value) || !hasExactShape(value, PREPARED_REQUEST_OBSERVATION_SHAPE))
+        return false;
+    return (value.schemaVersion === PREPARED_REQUEST_OBSERVATION_SCHEMA_VERSION &&
+        isSha256Digest(value.digest) &&
+        isNonNegativeInteger(value.bytes) &&
+        Array.isArray(value.segments) &&
+        value.segments.length <= PREPARED_REQUEST_OBSERVATION_MAX_SEGMENTS &&
+        value.segments.every(isPreparedRequestObservationSegment) &&
+        hasOrderedPreparedRequestSegments(value.segments));
+}
+function hasOrderedPreparedRequestSegments(segments) {
+    let previousKind = -1;
+    let previousIndex = -1;
+    for (const segment of segments) {
+        const kind = PREPARED_REQUEST_SEGMENT_KINDS.indexOf(segment.kind);
+        if (kind < previousKind)
+            return false;
+        if (kind === previousKind && segment.index <= previousIndex)
+            return false;
+        if (kind !== previousKind)
+            previousIndex = -1;
+        previousKind = kind;
+        previousIndex = segment.index;
+    }
+    return true;
+}
 const PRICING_RATES_SHAPE = defineObjectShape()(['modelKey', 'inputUsdPer1M', 'outputUsdPer1M'], ['cacheReadUsdPer1M', 'cacheWriteUsdPer1M']);
 /**
  * Audit-quality gate on the rates a cost was computed against. Held to the same
@@ -165,6 +295,7 @@ export function decodeModelCallAttempt(value) {
         isNonEmptyString(value.runId) &&
         isNonEmptyString(value.turnId) &&
         isNonNegativeInteger(value.step) &&
+        isOptionalString(value.requestCompositionId) &&
         isNonNegativeInteger(value.attempt) &&
         MODEL_CALL_KINDS.includes(value.callKind) &&
         (value.historyCompactRoute === undefined ||
@@ -174,6 +305,9 @@ export function decodeModelCallAttempt(value) {
         isNonEmptyString(value.modelId) &&
         isOptionalNonNegativeNumber(value.contextWindow) &&
         isOptionalString(value.captureArtifactId) &&
+        (value.promptComposition === undefined || isPromptComposition(value.promptComposition)) &&
+        (value.requestObservation === undefined ||
+            isPreparedRequestObservation(value.requestObservation)) &&
         isFiniteNumber(value.startedAt) &&
         isFiniteNumber(value.completedAt) &&
         isNonNegativeNumber(value.latencyMs) &&
@@ -217,15 +351,6 @@ export function decodeModelCallAttempt(value) {
     }
     return value;
 }
-export function isModelCallAttempt(value) {
-    try {
-        decodeModelCallAttempt(value);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
 /**
  * Collapses re-appended records by `attemptId`, keeping the last occurrence.
  *
@@ -257,76 +382,3 @@ export function groupModelCallAttempts(attempts) {
     }
     return [...groups.values()];
 }
-/**
- * The attempt that settled a logical call: the highest `attempt` ordinal that
- * reached a provider outcome. Terminality is a projection concern, not a stored
- * field, so it is derived rather than recorded.
- */
-export function settledAttempt(group) {
-    let settled;
-    for (const attempt of group.attempts) {
-        if (!settled || attempt.attempt > settled.attempt)
-            settled = attempt;
-    }
-    return settled;
-}
-/**
- * Extracts the canonical attempts a run committed, from that run's AgentRun
- * events. This is the projection the Usage read model is rebuilt through, so it
- * has to be total: an event that cannot be decoded is counted, not thrown, or
- * one bad record would block every later one in the same run from ever being
- * projected.
- */
-export function modelCallAttemptsFromRunEvents(events) {
-    const attempts = [];
-    let unreadableEvents = 0;
-    for (const event of events) {
-        if (event.type !== MODEL_CALL_ATTEMPT_EVENT_TYPE)
-            continue;
-        try {
-            attempts.push(decodeModelCallAttempt(event.data));
-        }
-        catch {
-            unreadableEvents += 1;
-        }
-    }
-    return { attempts, unreadableEvents };
-}
-export function summarizeModelCallCoverage(attempts) {
-    const unique = dedupeModelCallAttempts(attempts);
-    const coverage = {
-        attempts: unique.length,
-        pricedAttempts: 0,
-        unpricedAttempts: 0,
-        usageReportedAttempts: 0,
-        usagePartialAttempts: 0,
-        usageMissingAttempts: 0,
-    };
-    for (const attempt of unique) {
-        if (attempt.costBasis === 'priced')
-            coverage.pricedAttempts += 1;
-        else
-            coverage.unpricedAttempts += 1;
-        if (attempt.usageBasis === 'reported')
-            coverage.usageReportedAttempts += 1;
-        else if (attempt.usageBasis === 'partial')
-            coverage.usagePartialAttempts += 1;
-        else
-            coverage.usageMissingAttempts += 1;
-    }
-    return coverage;
-}
-/**
- * Sums cost across attempts. Returns the total alongside the coverage that
- * qualifies it, because a bare number cannot express "plus an unknown amount
- * from unpriced calls".
- */
-export function sumModelCallCostUsd(attempts) {
-    const unique = dedupeModelCallAttempts(attempts);
-    let costUsd = 0;
-    for (const attempt of unique) {
-        if (attempt.costBasis === 'priced' && attempt.costUsd !== undefined)
-            costUsd += attempt.costUsd;
-    }
-    return { costUsd, coverage: summarizeModelCallCoverage(unique) };
-}