@mupt-ai/dari-gateway 0.1.0 → 0.2.1

package/dist/telemetry/requests/interaction_observability.js

@@ -0,0 +1,180 @@
+import { isBackgroundRequest, } from "../../interaction/types.js";
+const SCHEMA_VERSION = 1;
+export function extractInteractionObservability(request) {
+    const metadata = interactionObservabilityMetadata(request);
+    return {
+        requestKind: interactionRequestKind(request),
+        messageCount: metadata.item_counts.message,
+        hasTools: metadata.declared_tool_counts.total > 0,
+        metadata,
+    };
+}
+function interactionObservabilityMetadata(request) {
+    const itemCounts = {
+        total: request.items.length,
+        message: 0,
+        reasoning: 0,
+        tool_call: 0,
+        tool_result: 0,
+        hosted_tool_call: 0,
+        hosted_tool_result: 0,
+    };
+    const messageRoleCounts = {
+        system: 0,
+        developer: 0,
+        user: 0,
+        assistant: 0,
+    };
+    const toolCallCounts = {
+        function: 0,
+        custom: 0,
+        hosted: 0,
+    };
+    const itemContentModalityCounts = {
+        text: 0,
+        image: 0,
+    };
+    const continuationStateCounts = {
+        total: 0,
+        openai_reasoning: 0,
+        anthropic_thinking: 0,
+        anthropic_redacted_thinking: 0,
+    };
+    for (const item of request.items) {
+        if (item.type === "message") {
+            itemCounts.message += 1;
+            messageRoleCounts[item.role] += 1;
+            addContentModalities(itemContentModalityCounts, item.content);
+            continue;
+        }
+        if (item.type === "reasoning") {
+            itemCounts.reasoning += 1;
+            if (item.continuation) {
+                continuationStateCounts.total += 1;
+                continuationStateCounts[item.continuation.kind] += 1;
+            }
+            continue;
+        }
+        if (item.type === "tool_call") {
+            itemCounts.tool_call += 1;
+            toolCallCounts[item.kind] += 1;
+            continue;
+        }
+        if (item.type === "tool_result") {
+            itemCounts.tool_result += 1;
+            addContentModalities(itemContentModalityCounts, item.output);
+            continue;
+        }
+        if (item.type === "reasoning_configuration") {
+            continue;
+        }
+        if (item.providerType === "tool_search_result") {
+            itemCounts.hosted_tool_result += 1;
+        }
+        else {
+            itemCounts.hosted_tool_call += 1;
+            toolCallCounts.hosted += 1;
+        }
+    }
+    const declaredToolCounts = {
+        total: request.tools.length,
+        function: 0,
+        custom: 0,
+        hosted: 0,
+    };
+    for (const tool of request.tools) {
+        const kind = tool.kind === "server_tool" ? "hosted" : tool.kind === "client_tool" ? "function" : tool.kind;
+        declaredToolCounts[kind] += 1;
+    }
+    const controls = {};
+    if (request.reasoning?.effort !== undefined) {
+        controls.reasoning_effort = request.reasoning.effort;
+    }
+    if (request.reasoning?.enabled !== undefined) {
+        controls.reasoning_enabled = request.reasoning.enabled;
+    }
+    if (request.responseFormat !== undefined) {
+        controls.response_format = request.responseFormat.type;
+    }
+    if (request.toolChoice !== undefined) {
+        controls.tool_choice = toolChoiceKind(request.toolChoice);
+    }
+    if (request.parallelToolCalls !== undefined) {
+        controls.parallel_tool_calls = request.parallelToolCalls;
+    }
+    return {
+        schema_version: SCHEMA_VERSION,
+        ...(request.agentContext === undefined ? {} : { agent_context: request.agentContext }),
+        item_counts: itemCounts,
+        message_role_counts: messageRoleCounts,
+        tool_call_counts: toolCallCounts,
+        declared_tool_counts: declaredToolCounts,
+        item_content_modality_counts: itemContentModalityCounts,
+        continuation_state_counts: continuationStateCounts,
+        instructions_present: request.instructions !== undefined
+            || messageRoleCounts.system > 0
+            || messageRoleCounts.developer > 0,
+        reasoning_history_present: itemCounts.reasoning > 0,
+        prompt_cache_key_present: request.promptCacheKey !== undefined,
+        user_present: request.user !== undefined,
+        controls,
+    };
+}
+function interactionRequestKind(request) {
+    if (isBackgroundRequest(request) ||
+        request.requestPurpose === "memory_extraction")
+        return "other";
+    if (request.requestPurpose === "tool_continuation") {
+        return "tool_continuation";
+    }
+    let hasTrailingToolResult = false;
+    for (let index = request.items.length - 1; index >= 0; index -= 1) {
+        const item = request.items[index];
+        if (item.type === "tool_result") {
+            hasTrailingToolResult = true;
+            continue;
+        }
+        if (item.type === "tool_call"
+            || item.type === "hosted_tool_call"
+            || item.type === "reasoning") {
+            return hasTrailingToolResult ? "tool_continuation" : "other";
+        }
+        if (item.type !== "message")
+            continue;
+        if (item.role === "system" || item.role === "developer")
+            continue;
+        if (item.role === "user") {
+            if (hasMeaningfulUserContent(item.content))
+                return "user_message";
+            continue;
+        }
+        return hasTrailingToolResult ? "tool_continuation" : "other";
+    }
+    return hasTrailingToolResult ? "tool_continuation" : "other";
+}
+export function hasMeaningfulUserContent(content) {
+    if (typeof content === "string")
+        return content.trim().length > 0;
+    if (!Array.isArray(content))
+        return false;
+    return content.some((part) => {
+        if (part.type === "text")
+            return part.text.trim().length > 0;
+        return true;
+    });
+}
+function addContentModalities(counts, content) {
+    if (typeof content === "string") {
+        counts.text += 1;
+        return;
+    }
+    if (!Array.isArray(content))
+        return;
+    for (const part of content) {
+        if (part.type === "text" || part.type === "image")
+            counts[part.type] += 1;
+    }
+}
+function toolChoiceKind(choice) {
+    return typeof choice === "string" ? choice : choice.kind;
+}

package/dist/telemetry/requests/retained_interaction_request.d.ts

@@ -0,0 +1,8 @@
+import type { InteractionRequest } from "../../interaction/types.js";
+export declare const RETAINED_INTERACTION_REQUEST_FORMAT: "interaction_request_v1";
+type RetainedInteractionRequest = {
+    format: typeof RETAINED_INTERACTION_REQUEST_FORMAT;
+    json: string;
+};
+export declare function encodeRetainedInteractionRequest(request: InteractionRequest): RetainedInteractionRequest;
+export {};

package/dist/telemetry/requests/retained_interaction_request.js

@@ -0,0 +1,10 @@
+export const RETAINED_INTERACTION_REQUEST_FORMAT = "interaction_request_v1";
+// This is a normalized InteractionRequest snapshot, not the original wire
+// body. Compatible fields may be added in v1; semantic or structural changes
+// require a new persisted format and a matching reader.
+export function encodeRetainedInteractionRequest(request) {
+    return {
+        format: RETAINED_INTERACTION_REQUEST_FORMAT,
+        json: JSON.stringify(request),
+    };
+}

package/dist/telemetry/scrub.d.ts

@@ -0,0 +1,2 @@
+export declare function scrubSecrets(text: string, secrets?: readonly string[]): string;
+export declare function scrubSecretValues(value: unknown, secrets: readonly string[]): unknown;

package/dist/telemetry/scrub.js

@@ -0,0 +1,31 @@
+// Error text can quote a credential the provider echoed back, so it gets the
+// `sk-` heuristic on top of exact-secret replacement.
+export function scrubSecrets(text, secrets = []) {
+    return replaceSecrets(text.replace(/sk-[A-Za-z0-9+/_=-]{8,}/g, "sk-…"), secrets);
+}
+// Provider payloads carry opaque base64 (OpenAI `encrypted_content`, image
+// data, signatures) where `sk-` occurs by chance. The regex heuristic would
+// truncate that ciphertext and poison every later turn of the conversation,
+// so structured payloads only get exact-secret replacement; error text is
+// scrubbed with the heuristic at the client and log boundaries.
+export function scrubSecretValues(value, secrets) {
+    if (typeof value === "string")
+        return replaceSecrets(value, secrets);
+    if (Array.isArray(value)) {
+        return value.map((item) => scrubSecretValues(item, secrets));
+    }
+    if (typeof value !== "object" || value === null)
+        return value;
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+        key,
+        scrubSecretValues(item, secrets),
+    ]));
+}
+function replaceSecrets(text, secrets) {
+    const uniqueSecrets = [...new Set(secrets.filter(Boolean))].sort((left, right) => right.length - left.length);
+    let scrubbed = text;
+    for (const secret of uniqueSecrets) {
+        scrubbed = scrubbed.replaceAll(secret, "…");
+    }
+    return scrubbed;
+}

package/dist/telemetry/skills/claude/catalog.d.ts

@@ -0,0 +1,6 @@
+import type { InteractionRequest } from "../../../interaction/types.js";
+export declare function claudeAvailableSkillNames(request: InteractionRequest): Set<string>;
+/** Read only harness-owned catalogs when attributing model-emitted file reads. */
+export declare function claudeSystemSkillNames(request: InteractionRequest): Set<string>;
+export declare function claudeSkillCapabilityId(name: string): string;
+export declare function normalizedClaudeSkillName(value: unknown): string | undefined;

package/dist/telemetry/skills/claude/catalog.js

@@ -0,0 +1,99 @@
+const MAX_CAPABILITY_ID_CHARS = 512;
+const MAX_SKILL_NAME_CHARS = 512;
+const CAPABILITY_PREFIX = "claude:name:";
+const UNSAFE_DISPLAY_CHARACTERS = /[\u0000-\u001f\u007f-\u009f\u202a-\u202e\u2066-\u2069]/u;
+const SKILL_NAME = new RegExp("^[A-Za-z0-9][A-Za-z0-9_.@-]*"
+    + "(?::[A-Za-z0-9][A-Za-z0-9_.@-]*"
+    + "|(?:/[A-Za-z0-9][A-Za-z0-9_.@-]*)+:[A-Za-z0-9][A-Za-z0-9_.@-]*)?$");
+const AVAILABLE_SKILLS_HEADING = "The following skills are available for use with the Skill tool:";
+const REMINDER_SKILLS_HEADER = `<system-reminder>\n${AVAILABLE_SKILLS_HEADING}\n`;
+const BARE_SKILLS_HEADER = `${AVAILABLE_SKILLS_HEADING}\n`;
+const SYSTEM_REMINDER_END = "\n</system-reminder>";
+export function claudeAvailableSkillNames(request) {
+    return parsedAvailableSkillNames(request, true);
+}
+/** Read only harness-owned catalogs when attributing model-emitted file reads. */
+export function claudeSystemSkillNames(request) {
+    return parsedAvailableSkillNames(request, false);
+}
+export function claudeSkillCapabilityId(name) {
+    return `${CAPABILITY_PREFIX}${name}`;
+}
+export function normalizedClaudeSkillName(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const withoutLeadingSlash = value.startsWith("/") ? value.slice(1) : value;
+    const normalized = withoutLeadingSlash.normalize("NFC").trim();
+    return normalized.length > 0
+        && normalized.length <= MAX_SKILL_NAME_CHARS
+        && normalized.length <= MAX_CAPABILITY_ID_CHARS - CAPABILITY_PREFIX.length
+        && SKILL_NAME.test(normalized)
+        && !UNSAFE_DISPLAY_CHARACTERS.test(normalized)
+        ? normalized
+        : undefined;
+}
+function parsedAvailableSkillNames(request, includeUserMessages) {
+    let latestNames = new Set();
+    for (const item of request.items) {
+        if (item.type !== "message"
+            || (item.role !== "system"
+                && item.role !== "developer"
+                && (!includeUserMessages || item.role !== "user")))
+            continue;
+        for (const part of item.content) {
+            if (part.type !== "text")
+                continue;
+            for (const section of availableSkillsSections(part.text, item.role)) {
+                const names = new Set();
+                let foundSkill = false;
+                for (const line of section.split("\n")) {
+                    if (line === "" && !foundSkill)
+                        continue;
+                    if (line === "")
+                        break;
+                    if (!line.startsWith("- "))
+                        continue;
+                    const name = availableSkillName(line);
+                    if (name === undefined)
+                        break;
+                    names.add(name);
+                    foundSkill = true;
+                }
+                latestNames = names;
+            }
+        }
+    }
+    return latestNames;
+}
+function availableSkillsSections(text, role) {
+    const sections = [];
+    let cursor = 0;
+    while (cursor < text.length) {
+        const start = text.indexOf(REMINDER_SKILLS_HEADER, cursor);
+        if (start < 0)
+            break;
+        const sectionStart = start + REMINDER_SKILLS_HEADER.length;
+        const sectionEnd = text.indexOf(SYSTEM_REMINDER_END, sectionStart);
+        if (sectionEnd < 0)
+            break;
+        sections.push(text.slice(sectionStart, sectionEnd));
+        cursor = sectionEnd + SYSTEM_REMINDER_END.length;
+    }
+    if (role !== "user") {
+        let bareCursor = 0;
+        while (bareCursor < text.length) {
+            const start = text.indexOf(BARE_SKILLS_HEADER, bareCursor);
+            if (start < 0)
+                break;
+            const sectionStart = start + BARE_SKILLS_HEADER.length;
+            sections.push(text.slice(sectionStart));
+            bareCursor = sectionStart;
+        }
+    }
+    return sections;
+}
+function availableSkillName(line) {
+    const entry = line.slice(2);
+    const description = entry.indexOf(": ");
+    return normalizedClaudeSkillName(description < 0 ? entry : entry.slice(0, description));
+}

package/dist/telemetry/skills/claude/file_reads.d.ts

@@ -0,0 +1,4 @@
+import type { InteractionOutput, InteractionRequest } from "../../../interaction/types.js";
+import type { SkillObservation } from "../observations.js";
+/** Match model-emitted Claude Code `Read` calls to its trusted skill catalog. */
+export declare function claudeFileReadObservations(request: InteractionRequest, output: InteractionOutput, limit: number): SkillObservation[];

package/dist/telemetry/skills/claude/file_reads.js

@@ -0,0 +1,110 @@
+import { interactionToolInput } from "../../tools/input.js";
+import { claudeSkillCapabilityId, claudeSystemSkillNames, } from "./catalog.js";
+import { normalizedAbsoluteSkillPath, skillPathSegments, } from "../paths.js";
+import { readPathsFromShellCommand } from "../shell_file_reads.js";
+const MAX_COMMAND_CHARS = 64 * 1024;
+const SKILL_FILE_NAME = "SKILL.md";
+const SKILLS_DIRECTORY_NAME = "skills";
+const PRIMARY_WORKING_DIRECTORY_PREFIX = " - Primary working directory: ";
+const UNSAFE_COMMAND_CHARACTERS = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f\u202a-\u202e\u2066-\u2069]/u;
+/** Match model-emitted Claude Code `Read` calls to its trusted skill catalog. */
+export function claudeFileReadObservations(request, output, limit) {
+    if (limit <= 0
+        || request.sourceProtocol !== "anthropic_messages")
+        return [];
+    const declaredTools = new Set(request.tools.flatMap((tool) => tool.kind === "function" && tool.namespace === undefined
+        ? [tool.name]
+        : []));
+    if (!declaredTools.has("Read") && !declaredTools.has("Bash"))
+        return [];
+    const availableSkills = claudeSystemSkillNames(request);
+    if (availableSkills.size === 0)
+        return [];
+    const workingDirectory = declaredTools.has("Bash")
+        ? claudePrimaryWorkingDirectory(request)
+        : undefined;
+    const observedCapabilities = new Set();
+    const observations = [];
+    for (const item of output.items) {
+        for (const read of claudeReadCalls(item, declaredTools, workingDirectory)) {
+            const name = skillNameForReadPath(read.path, availableSkills);
+            if (name === undefined)
+                continue;
+            const capabilityId = claudeSkillCapabilityId(name);
+            if (observedCapabilities.has(capabilityId))
+                continue;
+            observedCapabilities.add(capabilityId);
+            observations.push({
+                eventType: "skill_load",
+                toolCallId: read.callId,
+                capabilityId,
+                observedName: name,
+                evidenceSource: "skill_file_read",
+            });
+            if (observations.length === limit)
+                return observations;
+        }
+    }
+    return observations;
+}
+function claudeReadCalls(item, declaredTools, workingDirectory) {
+    if (item.type !== "tool_call"
+        || item.kind !== "function"
+        || item.namespace !== undefined
+        || !declaredTools.has(item.name))
+        return [];
+    const input = interactionToolInput(item);
+    if (item.name === "Read") {
+        const path = normalizedAbsoluteSkillPath(input?.file_path);
+        return path === undefined ? [] : [{ callId: item.callId, path }];
+    }
+    if (item.name !== "Bash" || workingDirectory === undefined)
+        return [];
+    const command = input?.command;
+    if (typeof command !== "string"
+        || command.length === 0
+        || command.length > MAX_COMMAND_CHARS
+        || UNSAFE_COMMAND_CHARACTERS.test(command))
+        return [];
+    return readPathsFromShellCommand({
+        command,
+        workdir: workingDirectory.value,
+    }, workingDirectory.platform).map((path) => ({ callId: item.callId, path }));
+}
+function claudePrimaryWorkingDirectory(request) {
+    if (request.instructions === undefined)
+        return undefined;
+    const matches = request.instructions.split("\n").flatMap((line) => line.startsWith(PRIMARY_WORKING_DIRECTORY_PREFIX)
+        ? [line.slice(PRIMARY_WORKING_DIRECTORY_PREFIX.length)]
+        : []);
+    if (matches.length !== 1)
+        return undefined;
+    return normalizedAbsoluteSkillPath(matches[0]);
+}
+function skillNameForReadPath(path, availableSkills) {
+    const segments = skillPathSegments(path);
+    const fileName = segments.at(-1);
+    const directoryName = segments.at(-2);
+    if (fileName === undefined
+        || directoryName === undefined
+        || normalizedPathPart(fileName, path) !== normalizedPathPart(SKILL_FILE_NAME, path)
+        || !segments.slice(0, -2).some((segment) => normalizedPathPart(segment, path)
+            === normalizedPathPart(SKILLS_DIRECTORY_NAME, path)))
+        return undefined;
+    let match;
+    for (const name of availableSkills) {
+        const separator = name.lastIndexOf(":");
+        const pathName = separator < 0 ? name : name.slice(separator + 1);
+        if (normalizedPathPart(pathName, path) !== normalizedPathPart(directoryName, path)) {
+            continue;
+        }
+        if (match !== undefined)
+            return undefined;
+        match = name;
+    }
+    return match;
+}
+function normalizedPathPart(value, path) {
+    const normalized = value.normalize("NFC");
+    return path.platform === "windows" ? normalized.toLowerCase() : normalized;
+}

package/dist/telemetry/skills/claude/observations.d.ts

@@ -0,0 +1,3 @@
+import type { InteractionRequest } from "../../../interaction/types.js";
+import type { SkillObservation } from "../observations.js";
+export declare function claudeSkillObservations(request: InteractionRequest, limit: number): SkillObservation[];