@xfey/tenso 0.1.130

package/dist/communication-language/index.d.ts

@@ -0,0 +1,75 @@
+import type { MessageProjection } from "@tutti/shared/schemas/api";
+export declare const COMMUNICATION_LANGUAGE_POLICY_VERSION = 1;
+export type LanguagePreference = {
+    locale: string;
+    preference: "auto" | "fixed";
+};
+export type LanguageDecision = LanguagePreference & {
+    basis: "discussion" | "explicit" | "inherited" | "default";
+    evidence_index: number | null;
+};
+export type LanguageEvidenceMessage = {
+    role: "human" | "tutti" | "operator" | "system";
+    text: string;
+};
+export declare function messageLanguageEvidence(message: MessageProjection): LanguageEvidenceMessage;
+export type CommunicationLanguageContext = {
+    policy_version: 1;
+    scope: "scratchpad" | "reply" | "workflow" | "summary" | "documents";
+    inherited: LanguagePreference | null;
+    pinned: boolean;
+    evidence: Array<{
+        role: "human" | "operator";
+        text: string;
+    }>;
+};
+export declare function isLanguagePreference(value: unknown): value is LanguagePreference;
+export declare function isLanguageDecision(value: unknown): value is LanguageDecision;
+/** A language sample, not task context. The original message is never rewritten. */
+export declare function authoredLanguageSample(text: string): string;
+export declare function createLanguageContext(input: {
+    scope: CommunicationLanguageContext["scope"];
+    inherited?: LanguagePreference | null;
+    pinned?: boolean;
+    messages?: readonly LanguageEvidenceMessage[];
+}): CommunicationLanguageContext;
+export declare function languageDecisionMatchesContext(decision: unknown, context: CommunicationLanguageContext): decision is LanguageDecision;
+export declare function languageDiagnosticFields(context: CommunicationLanguageContext): {
+    language_policy_version: 1;
+    language_scope: "scratchpad" | "summary" | "workflow" | "reply" | "documents";
+    language_locale: string;
+    language_pinned: boolean;
+    language_evidence_count: number;
+};
+export type LanguageAwareOutput = {
+    communication_language?: LanguageDecision;
+};
+export declare const LANGUAGE_DECISION_SCHEMA: {
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["locale", "preference", "basis", "evidence_index"];
+    readonly properties: {
+        readonly locale: {
+            readonly type: "string";
+            readonly pattern: string;
+        };
+        readonly preference: {
+            readonly type: "string";
+            readonly enum: readonly ["auto", "fixed"];
+        };
+        readonly basis: {
+            readonly type: "string";
+            readonly enum: readonly ["discussion", "explicit", "inherited", "default"];
+        };
+        readonly evidence_index: {
+            readonly anyOf: readonly [{
+                readonly type: "integer";
+                readonly minimum: 0;
+                readonly maximum: 11;
+            }, {
+                readonly type: "null";
+            }];
+        };
+    };
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/communication-language/index.js

@@ -0,0 +1,122 @@
+export const COMMUNICATION_LANGUAGE_POLICY_VERSION = 1;
+export function messageLanguageEvidence(message) {
+    const feedback = message.refs?.artifact_feedback;
+    return {
+        role: message.author.kind === "human"
+            ? "human"
+            : message.refs?.development_operator === true
+                ? "operator"
+                : "system",
+        text: message.refs?.reference_file !== undefined
+            ? ""
+            : feedback === undefined
+                ? message.body
+                : [feedback.summary, ...feedback.annotations.map((entry) => entry.comment)]
+                    .filter(Boolean)
+                    .join("\n"),
+    };
+}
+const BASES = new Set(["discussion", "explicit", "inherited", "default"]);
+const LOCALE_PATTERN = /^[a-z]{2,3}(?:-[A-Z][a-z]{3})?(?:-[A-Z]{2}|-\d{3})?$/u;
+export function isLanguagePreference(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const entry = value;
+    if (entry.preference !== "auto" && entry.preference !== "fixed")
+        return false;
+    if (typeof entry.locale !== "string" || !LOCALE_PATTERN.test(entry.locale))
+        return false;
+    try {
+        return Intl.getCanonicalLocales(entry.locale)[0] === entry.locale && entry.locale !== "und";
+    }
+    catch {
+        return false;
+    }
+}
+export function isLanguageDecision(value) {
+    if (!isLanguagePreference(value))
+        return false;
+    const entry = value;
+    return (BASES.has(entry.basis ?? "") &&
+        (entry.evidence_index === null ||
+            (Number.isSafeInteger(entry.evidence_index) && (entry.evidence_index ?? -1) >= 0)) &&
+        Object.keys(value).every((key) => ["locale", "preference", "basis", "evidence_index"].includes(key)));
+}
+/** A language sample, not task context. The original message is never rewritten. */
+export function authoredLanguageSample(text) {
+    const sample = text
+        .replace(/```[^]*?```|~~~[^]*?~~~/gu, " ")
+        .replace(/^(?: {0,3}>| {4}|\t).*$/gmu, " ")
+        .replace(/`[^`]*`/gu, " ")
+        .replace(/!\[[^\]]*\]\([^)]*\)/gu, " ")
+        .replace(/\[([^\]]+)\]\([^)]*\)/gu, "$1")
+        .replace(/https?:\/\/\S+|@tenso\b/giu, " ")
+        .replace(/\s+/gu, " ")
+        .trim();
+    return sample.length <= 800 ? sample : `${sample.slice(0, 398)} … ${sample.slice(-399)}`;
+}
+export function createLanguageContext(input) {
+    const evidence = (input.messages ?? []).flatMap((message) => {
+        if (message.role !== "human" && message.role !== "operator")
+            return [];
+        const text = authoredLanguageSample(message.text);
+        return /\p{L}/u.test(text) ? [{ role: message.role, text }] : [];
+    });
+    // Prefer humans. Operator-only tests can infer locally but cannot update project memory.
+    const selected = input.scope !== "reply" && evidence.some((entry) => entry.role === "human")
+        ? evidence.filter((entry) => entry.role === "human")
+        : evidence;
+    return {
+        policy_version: COMMUNICATION_LANGUAGE_POLICY_VERSION,
+        scope: input.scope,
+        inherited: input.inherited == null
+            ? null
+            : { locale: input.inherited.locale, preference: input.inherited.preference },
+        pinned: input.pinned ?? false,
+        evidence: selected.slice(-12),
+    };
+}
+export function languageDecisionMatchesContext(decision, context) {
+    if (!isLanguageDecision(decision))
+        return false;
+    if (decision.basis === "inherited") {
+        return (decision.evidence_index === null &&
+            decision.locale === context.inherited?.locale &&
+            decision.preference === context.inherited.preference);
+    }
+    if (decision.basis === "default") {
+        return (decision.evidence_index === null &&
+            context.inherited === null &&
+            decision.locale === "en" &&
+            decision.preference === "auto");
+    }
+    if (decision.evidence_index === null || !context.evidence[decision.evidence_index])
+        return false;
+    if (context.scope === "summary" || context.scope === "documents")
+        return false;
+    if (decision.basis === "discussion") {
+        return (!context.pinned && context.inherited?.preference !== "fixed" && decision.preference === "auto");
+    }
+    return true;
+}
+export function languageDiagnosticFields(context) {
+    return {
+        language_policy_version: context.policy_version,
+        language_scope: context.scope,
+        language_locale: context.inherited?.locale ?? "undetermined",
+        language_pinned: context.pinned,
+        language_evidence_count: context.evidence.length,
+    };
+}
+export const LANGUAGE_DECISION_SCHEMA = {
+    type: "object",
+    additionalProperties: false,
+    required: ["locale", "preference", "basis", "evidence_index"],
+    properties: {
+        locale: { type: "string", pattern: LOCALE_PATTERN.source },
+        preference: { type: "string", enum: ["auto", "fixed"] },
+        basis: { type: "string", enum: ["discussion", "explicit", "inherited", "default"] },
+        evidence_index: { anyOf: [{ type: "integer", minimum: 0, maximum: 11 }, { type: "null" }] },
+    },
+};
+//# sourceMappingURL=index.js.map

package/dist/communication-language/live-smoke-cli.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=live-smoke-cli.d.ts.map

package/dist/communication-language/live-smoke-cli.js

@@ -0,0 +1,368 @@
+import { execFileSync } from "node:child_process";
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { parseArgs, parseEnv } from "node:util";
+import { createActivityRef, createProjectId, createTaskId, createTaskModuleId, createWorkflowInvocationRef, } from "@tutti/shared/ids";
+import { createOpenAiProcedureWorkflowRunner } from "../control-plane/workflows/openai.js";
+import { createOpenAiStructuredOutputClient, OpenAiStructuredOutputError, } from "../providers/openai/sdk-procedure-runner.js";
+import { runWorkspaceWriteTask } from "../run-pipeline/task-run-invocation.js";
+import { CodexAppServerWorkspaceWriteRunError } from "../providers/openai/app-server/workspace-write-run.js";
+import { CodexAppServerReadOnlyProcedureError } from "../providers/openai/app-server/read-only-procedure.js";
+import { createLanguageContext } from "./index.js";
+import { isLanguageDecision, languageDecisionMatchesContext, } from "./index.js";
+import { isScratchpadRefreshStructuredOutput } from "../control-plane/workflows/structured-output.js";
+// Opt-in paid synthetic evaluation, never called by Host or normal unit tests.
+let activeCase = "configuration";
+let expectedLanguage;
+let lastProgress = "";
+const smokeStartedAt = Date.now();
+function reportProgress(stage, action) {
+    const key = `${activeCase}:${stage}:${action ?? ""}`;
+    if (key === lastProgress)
+        return;
+    lastProgress = key;
+    console.log(JSON.stringify({
+        case: activeCase,
+        stage,
+        ...(action === undefined ? {} : { action }),
+        elapsed_ms: Date.now() - smokeStartedAt,
+    }));
+}
+function report(status) {
+    console.log(JSON.stringify({ case: activeCase, status }));
+}
+class SmokeAssertionError extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+    }
+}
+function requireCondition(condition, code = "fixture_assertion_failed") {
+    if (!condition)
+        throw new SmokeAssertionError(code);
+}
+function proseMatches(text, locale) {
+    // A narrow fixture assertion, NOT a production language detector or translation gate.
+    return locale.startsWith("zh") ? /\p{Script=Han}/u.test(text) : !/\p{Script=Han}/u.test(text);
+}
+async function main() {
+    const { values } = parseArgs({
+        options: {
+            "env-file": { type: "string" },
+            model: { type: "string" },
+            "from-case": { type: "string" },
+            "turn-timeout-ms": { type: "string" },
+        },
+    });
+    if (!values["env-file"] || !values.model)
+        throw new Error("explicit_smoke_configuration_required");
+    const turnTimeoutMs = Number(values["turn-timeout-ms"] ?? 180_000);
+    requireCondition(Number.isSafeInteger(turnTimeoutMs) && turnTimeoutMs >= 30_000 && turnTimeoutMs <= 1_200_000);
+    // Do not export credentials into the process or child environment.
+    const env = parseEnv(readFileSync(values["env-file"], "utf8"));
+    const apiKey = env.TUTTI_API_KEY;
+    if (!apiKey)
+        throw new Error("missing_smoke_credential");
+    const config = {
+        default_model: values.model,
+        ...(env.TUTTI_BASE_URL ? { api_base_url: env.TUTTI_BASE_URL } : {}),
+    };
+    const root = mkdtempSync(join(tmpdir(), "tutti-language-smoke-"));
+    const workspaceRoot = join(root, "repo");
+    const privateHome = join(root, "home");
+    const tuttiHome = join(root, "tutti");
+    for (const path of [workspaceRoot, privateHome, tuttiHome])
+        mkdirSync(path, { mode: 0o700 });
+    let fixtureCleanupSafe = true;
+    const runtime = {
+        apiKey,
+        workspaceRoot,
+        tuttiHome,
+        projectId: createProjectId(),
+        baseEnv: { HOME: privateHome, PATH: process.env.PATH, LANG: "en_US.UTF-8" },
+        requestTimeoutMs: 60_000,
+        turnTimeoutMs,
+        onLifecycleIncident: (incident) => {
+            if (incident.code === "process_termination_failed")
+                fixtureCleanupSafe = false;
+            console.log(JSON.stringify({ case: activeCase, diagnostic: "lifecycle", reason_code: incident.code }));
+        },
+    };
+    try {
+        writeFileSync(join(workspaceRoot, "README.md"), "# English repository\n\nA minimal synthetic greeting fixture. Keep this README in English.\n", { mode: 0o600 });
+        for (const args of [
+            ["init", "-b", "main"],
+            ["config", "user.name", "Tutti Fixture"],
+            ["config", "user.email", "fixture@example.invalid"],
+            ["add", "."],
+            ["commit", "-m", "fixture"],
+        ])
+            execFileSync("git", args, { cwd: workspaceRoot, stdio: "ignore" });
+        const client = createOpenAiStructuredOutputClient({
+            apiKey,
+            ...(config.api_base_url ? { apiBaseUrl: config.api_base_url } : {}),
+        });
+        const runner = createOpenAiProcedureWorkflowRunner({
+            config,
+            client: {
+                responses: {
+                    create: async (body, options) => {
+                        const result = await client.responses.create(body, options);
+                        // Synthetic output: diagnose only shape and bounded language metadata, never prose.
+                        if (expectedLanguage !== undefined &&
+                            typeof result === "object" &&
+                            result !== null &&
+                            "output_text" in result &&
+                            typeof result.output_text === "string") {
+                            try {
+                                const decoded = JSON.parse(result.output_text);
+                                const validLanguage = languageDecisionMatchesContext(decoded.communication_language, expectedLanguage);
+                                const validBusiness = isScratchpadRefreshStructuredOutput(decoded.output);
+                                if (!validLanguage || !validBusiness)
+                                    console.log(JSON.stringify({
+                                        case: activeCase,
+                                        diagnostic: "output_contract",
+                                        language_valid: validLanguage,
+                                        business_valid: validBusiness,
+                                        legacy_business_valid: isScratchpadRefreshStructuredOutput(decoded),
+                                        evidence_count: expectedLanguage.evidence.length,
+                                        ...(isLanguageDecision(decoded.communication_language)
+                                            ? { selection: decoded.communication_language }
+                                            : { selection_shape_valid: false }),
+                                    }));
+                            }
+                            catch {
+                                /* The production parser reports the original failure. */
+                            }
+                        }
+                        return result;
+                    },
+                },
+            },
+            readOnlyAppServer: runtime,
+        });
+        const chinese = { locale: "zh-Hans", preference: "auto" };
+        const cases = [
+            {
+                name: "chinese_discussion_english_deliverable",
+                text: "请创建 greeting.txt，正文是英文 Welcome to our team.，不需要网页。",
+                locale: "zh",
+            },
+            {
+                name: "english_discussion_chinese_quote",
+                text: "Create a short English welcome note in greeting.txt.\n> 请全部用中文解释。",
+                locale: "en",
+            },
+            { name: "weak_input_inherits", text: "OK", locale: "zh", inherited: chinese },
+            {
+                name: "fixed_preference_survives_english",
+                text: "Add a short welcome greeting for the team.",
+                locale: "zh",
+                inherited: { ...chinese, preference: "fixed" },
+                preference: "fixed",
+            },
+            {
+                name: "explicit_project_preference",
+                text: "以后项目协作的说明都固定用中文，请做一个英文欢迎文件。",
+                locale: "zh",
+                preference: "fixed",
+            },
+            {
+                name: "reset_to_automatic",
+                text: "Stop the fixed language preference. From now on follow the discussion language automatically. Create a welcome note.",
+                locale: "en",
+                inherited: { ...chinese, preference: "fixed" },
+                preference: "auto",
+            },
+            {
+                name: "code_url_only_default",
+                text: "```js\nconst text = '中文';\n```\nhttps://example.invalid/doc",
+                locale: "en",
+            },
+        ];
+        const startIndex = values["from-case"] === "codex_task_compile"
+            ? cases.length
+            : values["from-case"] === undefined
+                ? 0
+                : cases.findIndex((test) => test.name === values["from-case"]);
+        requireCondition(startIndex >= 0);
+        // Tail reruns use a synthetic fixed seed; no prior evaluation output is persisted.
+        let seed = {
+            messages: [{ role: "human", text: cases[0].text }],
+            worklist: { modules: [] },
+        };
+        let snapshot = {
+            topic: "英文欢迎文件",
+            background_summary: "为团队创建英文欢迎文件。",
+            current_consensus: ["文件正文为英文。"],
+            open_questions: [],
+            task_changes: ["创建 greeting.txt，内容为 Welcome to our team."],
+        };
+        for (const test of cases.slice(startIndex)) {
+            activeCase = test.name;
+            report("started");
+            const messages = [
+                {
+                    role: "tutti",
+                    text: "Previous English analysis of this repository and possible implementation.",
+                },
+                { role: "human", text: test.text },
+            ];
+            const input = {
+                messages,
+                worklist: { modules: [] },
+                communication_language: createLanguageContext({
+                    scope: "scratchpad",
+                    ...(test.inherited ? { inherited: test.inherited } : {}),
+                    messages,
+                }),
+            };
+            expectedLanguage = input.communication_language;
+            const output = await runner.runScratchpadRefresh(input, {
+                workflow_ref: createWorkflowInvocationRef(),
+                activity_ref: createActivityRef(),
+            });
+            const language = output.communication_language;
+            const prose = output.decision === "ready"
+                ? [output.scratchpad_snapshot.topic, output.scratchpad_snapshot.background_summary].join(" ")
+                : output.request_payload.request;
+            const selectionMatches = language !== undefined && language.locale.startsWith(test.locale);
+            const preferenceMatches = test.preference === undefined || language?.preference === test.preference;
+            const proseLanguageMatches = proseMatches(prose, test.locale);
+            if (!selectionMatches || !preferenceMatches || !proseLanguageMatches) {
+                console.log(JSON.stringify({
+                    case: activeCase,
+                    diagnostic: "language_evaluation",
+                    expected_locale_prefix: test.locale,
+                    expected_preference: test.preference,
+                    actual_locale: language?.locale,
+                    actual_preference: language?.preference,
+                    actual_basis: language?.basis,
+                    selection_matches: selectionMatches,
+                    preference_matches: preferenceMatches,
+                    prose_language_matches: proseLanguageMatches,
+                }));
+            }
+            requireCondition(selectionMatches, "language_selection_mismatch");
+            requireCondition(preferenceMatches, "language_preference_mismatch");
+            requireCondition(proseLanguageMatches, "language_prose_mismatch");
+            if (test === cases[0] && output.decision === "ready") {
+                seed = input;
+                snapshot = output.scratchpad_snapshot;
+            }
+            report("passed");
+        }
+        activeCase = "codex_task_compile";
+        report("started");
+        const workflowRef = createWorkflowInvocationRef();
+        const language = createLanguageContext({ scope: "workflow", inherited: chinese, pinned: true });
+        const compiled = await runner.runTaskCompile({
+            workflow_ref: workflowRef,
+            communication_language: language,
+            scratchpad: snapshot,
+            source_messages: seed.messages,
+            worklist: { modules: [] },
+        }, {
+            workflow_ref: workflowRef,
+            activity_ref: createActivityRef(),
+            reportProgress: (progress) => reportProgress(progress.phase ?? "task_compile", progress.runtime?.current_action),
+        });
+        requireCondition(compiled.decision === "ready" && compiled.proposal.tasks.length === 1);
+        requireCondition(compiled.communication_language?.locale === "zh-Hans");
+        const proposed = compiled.proposal.tasks[0];
+        requireCondition(proseMatches(proposed.title + proposed.contract.goal, "zh"));
+        report("passed");
+        activeCase = "codex_execute_finalize_english_file";
+        report("started");
+        const taskId = createTaskId();
+        const moduleId = createTaskModuleId();
+        const activityRef = createActivityRef();
+        const now = new Date().toISOString();
+        const task = {
+            id: taskId,
+            module_id: moduleId,
+            title: proposed.title,
+            summary: proposed.summary,
+            status: "running",
+            order: 1,
+            current_activity_ref: activityRef,
+            created_from_workflow_ref: workflowRef,
+            created_at: now,
+            updated_at: now,
+        };
+        const result = await runWorkspaceWriteTask({ ...runtime, config }, {
+            communication_language: language,
+            on_stage: (progress) => reportProgress(progress.stage, progress.runtime?.current_action),
+            activity_ref: activityRef,
+            task,
+            task_detail: {
+                task,
+                detail: { task_id: taskId, contract: proposed.contract, result: {}, updated_at: now },
+            },
+            source_messages: seed.messages,
+            run_lineage: { kind: "initial", attempt: 1 },
+            dispatch_context: {
+                trigger: "manual_run_now",
+                queue_scope: { kind: "worklist" },
+                current_task_id: taskId,
+                ordered_task_refs: [taskId],
+                current_module_id: moduleId,
+            },
+        });
+        requireCondition(result.decision === "completed", "execute_result_unexpected");
+        requireCondition(proseMatches(result.summary, "zh"), "execute_language_mismatch");
+        requireCondition(readFileSync(join(workspaceRoot, "greeting.txt"), "utf8").trim() === "Welcome to our team.", "deliverable_mismatch");
+        const readme = readFileSync(join(workspaceRoot, "README.md"), "utf8");
+        requireCondition(readme.startsWith("# English repository") && proseMatches(readme, "en"), "existing_document_changed");
+        report("passed");
+        console.log(JSON.stringify({
+            status: "passed",
+            cases: cases.length - startIndex + 2,
+            model: config.default_model,
+            turn_timeout_ms: turnTimeoutMs,
+            ...(values["from-case"] === undefined ? {} : { from_case: values["from-case"] }),
+        }));
+    }
+    finally {
+        if (fixtureCleanupSafe)
+            rmSync(root, { recursive: true, force: true });
+        else
+            console.log(JSON.stringify({
+                case: activeCase,
+                diagnostic: "fixture_retained",
+                reason_code: "process_termination_unconfirmed",
+            }));
+    }
+}
+void main().catch((error) => {
+    console.error(JSON.stringify({
+        case: activeCase,
+        status: "failed",
+        reason_code: error instanceof OpenAiStructuredOutputError
+            ? error.reason
+            : error instanceof CodexAppServerWorkspaceWriteRunError ||
+                error instanceof CodexAppServerReadOnlyProcedureError ||
+                error instanceof SmokeAssertionError
+                ? error.code
+                : "language_smoke_failed",
+        ...(error instanceof OpenAiStructuredOutputError
+            ? { invalid_response_kind: error.invalidResponseKind }
+            : {}),
+        ...(error instanceof CodexAppServerWorkspaceWriteRunError
+            ? {
+                turn_start_state: error.details.turn_start_state,
+                turn_timeout_ms: error.details.turn_timeout_ms,
+                http_status: error.details.turn_error_http_status,
+                notification_count: error.details.notification_count,
+                server_request_count: error.details.server_request_methods?.length,
+                recent_methods_include_turn_started: error.details.notification_methods?.includes("turn/started"),
+                recent_methods_include_item_completed: error.details.notification_methods?.includes("item/completed"),
+                elapsed_ms: Date.now() - smokeStartedAt,
+            }
+            : {}),
+    }));
+    process.exitCode = 1;
+});
+//# sourceMappingURL=live-smoke-cli.js.map

package/dist/communication-language/notice-locale.d.ts

@@ -0,0 +1,4 @@
+/** Small static notice catalog, not language detection or a UI locale setting. */
+export type NoticeLocale = "en" | "zh-Hans" | "zh-Hant";
+export declare function noticeLocale(locale?: string | null): NoticeLocale;
+//# sourceMappingURL=notice-locale.d.ts.map

package/dist/communication-language/notice-locale.js

@@ -0,0 +1,14 @@
+export function noticeLocale(locale) {
+    if (locale === undefined || locale === null)
+        return "en";
+    try {
+        const parsed = new Intl.Locale(locale);
+        if (parsed.language !== "zh")
+            return "en";
+        return parsed.maximize().script === "Hant" ? "zh-Hant" : "zh-Hans";
+    }
+    catch {
+        return "en";
+    }
+}
+//# sourceMappingURL=notice-locale.js.map

package/dist/communication-language/prompt.d.ts

@@ -0,0 +1,22 @@
+import { type RenderPromptTemplateOptions } from "../prompt-templates/index.js";
+import { type CommunicationLanguageContext, type LanguageDecision } from "./index.js";
+export declare function renderLanguageAwarePrompt(options: RenderPromptTemplateOptions, language: CommunicationLanguageContext | undefined, reportLanguage?: boolean): string;
+type ObjectSchema = {
+    [key: string]: unknown;
+};
+export declare function languageOutputContract<T>(schema: ObjectSchema, validate: (value: unknown) => value is T, context: CommunicationLanguageContext | undefined): {
+    schema: ObjectSchema;
+    validate: (value: unknown) => value is T | {
+        communication_language: LanguageDecision;
+        output: T;
+    };
+    unwrap: (value: T | {
+        communication_language: LanguageDecision;
+        output: T;
+    }) => {
+        output: T;
+        language?: LanguageDecision;
+    };
+};
+export {};
+//# sourceMappingURL=prompt.d.ts.map