@retinue/agentkit 0.1.0 → 0.3.0

package/dist/agents/engine.js

@@ -18,10 +18,25 @@
  *    on a refusal the model cannot resolve.
  */
 import { AgentPlatformError, isAgentPlatformError } from "../core/errors.js";
+import { connectionNeedOf } from "../connections/pause.js";
 import { asId } from "../core/ids.js";
-import { streamModelTurn } from "../models/index.js";
+import { applyInputGuardrails, applyOutputGuardrails } from "../guardrails/index.js";
+import { streamModelTurn, turnText } from "../models/index.js";
 import { decideRetry, deriveRunMessageId, toPlatformError, DEFAULT_RETRY_POLICY, } from "../runtime/index.js";
+import { META_TOOLS } from "../tools/index.js";
+// The specific modules rather than `core/index.js`: the barrel pulls in `zod` through `core/validation.ts`,
+// and a subpath's dependency graph is a guarantee this package tests for.
+import { applyTokenBudget } from "../core/budget.js";
+import { estimateTokens } from "../core/tokens.js";
 import { isQuestionPending } from "../hitl/service.js";
+/**
+ * What one tool costs the model's context.
+ *
+ * A `ModelTurnTool` is not a catalogue entry — it carries the full input schema, because that is what a provider
+ * puts in the request — so this deliberately does *not* reuse `entryTokens`. Using the compact estimate here
+ * would understate a schema-heavy tool by an order of magnitude and produce a budget that never binds.
+ */
+export const turnToolTokens = (tool) => estimateTokens(`${tool.name} ${tool.description ?? ""}`) + estimateTokens(JSON.stringify(tool.inputSchema ?? {}));
 const defaultSleep = (ms) => new Promise((r) => setTimeout(r, ms));
 /**
  * Take citation candidates off a tool's result — #165.
@@ -83,18 +98,119 @@ const questionMarker = (thrown, toolName) => {
         },
     };
 };
+/**
+ * A record becomes an event, with no value ever attached.
+ *
+ * One place, so a future field on `GuardrailRecord` cannot reach the event log by being spread in somewhere: the
+ * mapping is explicit, field by field, and adding one here is a decision rather than a consequence.
+ */
+const verdictEvent = (record) => ({
+    type: "guardrail.verdict",
+    guardrail: record.guardrail,
+    subject: record.subject,
+    outcome: record.outcome,
+    ...(record.what === undefined ? {} : { what: record.what }),
+    ...(record.code === undefined ? {} : { code: record.code }),
+    ...(record.threw === undefined ? {} : { threw: record.threw }),
+});
 export const createDefaultEngine = (deps) => {
     const policy = deps.retry ?? DEFAULT_RETRY_POLICY;
     const sleep = deps.sleep ?? defaultSleep;
     const now = deps.now ?? Date.now;
     const streamTurn = deps.streamTurn ?? streamModelTurn;
     return {
-        async *run({ run, context, signal }) {
-            const manifest = await deps.loadManifest({ agentId: run.agentId, version: run.agentVersion, context });
+        async *run({ run, context: hostContext, signal }) {
+            const manifest = await deps.loadManifest({
+                agentId: run.agentId,
+                version: run.agentVersion,
+                context: hostContext,
+            });
+            /**
+             * The agent's tool policy, put on the context for everything downstream — task #244.
+             *
+             * The engine is the only layer that holds both halves: the manifest (per agent) and the registry (per
+             * deployment). Rather than threading the policy through `buildTools`, tool execution, `execute_tool` and
+             * every delegating tool, it travels on the context — which a model cannot write to, so `excluded` cannot
+             * be widened from inside a turn. `ExecutionContext.shadow` is the precedent and the same argument.
+             *
+             * Scoped **once, here**, and used everywhere below. A host-supplied context that already carried a policy
+             * is overridden by the manifest's: the manifest is what the run's `agentVersion` pins, so a stored
+             * definition — not the caller — decides what this agent may reach.
+             */
+            const context = { ...hostContext, agentToolPolicy: manifest.toolPolicy };
             const resolved = deps.resolveModel(manifest, context);
+            /**
+             * A structured agent needs a model that can do it — task #243 AC-3.
+             *
+             * Checked at resolution, before a token is spent, and here rather than only in the host's `resolveModel`
+             * because that callback is the host's: a host that has not been updated would resolve a text-only model
+             * and the agent would silently get prose, which is the defect being fixed rather than a new one.
+             *
+             * Skipped when the host returned no `definition`, following the same rule `modelModalities` already uses
+             * (#185): a caller that did not say what the model can do has not said it cannot do this, and refusing
+             * every structured agent from every host that has not been updated would be an outage dressed as a check.
+             */
+            if (manifest.responseFormat?.kind === "structured" && resolved.definition !== undefined) {
+                if (resolved.definition.capabilities?.structuredOutput !== true)
+                    throw new AgentPlatformError({
+                        code: "capability_unavailable",
+                        message: `agent "${manifest.id}" asks for a structured response format and the resolved model ` +
+                            `${resolved.modelId} does not declare the \`structuredOutput\` capability. Add ` +
+                            "`requiredCapabilities: { structuredOutput: true }` to the agent's model policy so resolution " +
+                            "picks a model that can, rather than discovering it mid-turn.",
+                        retryable: false,
+                    });
+            }
             const system = (await (deps.systemPrompt?.(manifest, context) ?? manifest.instructions)) || undefined;
             const history = await deps.loadHistory(context, run);
-            const declared = deps.buildTools ? await deps.buildTools(context, manifest) : [];
+            const built = deps.buildTools ? await deps.buildTools(context, manifest) : [];
+            /**
+             * The budget, applied to the list the model will actually see — AC-3.
+             *
+             * Meta-tools are protected: dropping `find_tools` to save its own ~35 tokens would leave the model with a
+             * shortened list and no way to discover that it was shortened, which is the failure this whole mechanism
+             * exists to prevent.
+             *
+             * `findable` is *derived* rather than configured. Whether truncation is a deferral or an amputation
+             * depends on one fact — is `find_tools` in the model's hands this turn — and asking the host to declare
+             * that separately would let the declaration be wrong.
+             */
+            const budgetOutcome = deps.catalogBudget === undefined
+                ? undefined
+                : applyTokenBudget({
+                    items: built,
+                    budget: deps.catalogBudget,
+                    tokensOf: turnToolTokens,
+                    nameOf: (tool) => tool.name,
+                    /**
+                     * Protected: meta-tools, and whatever the agent declared preloaded — task #244.
+                     *
+                     * `toolPolicy.preloaded` and `toolPolicy.categories` say "these are loaded up front; everything
+                     * else is discovered lazily". In this architecture *resident* is what "loaded up front" means, so
+                     * the honest interpretation of both fields is that a budget may not drop them. With no budget
+                     * configured every tool is resident anyway and the fields are a no-op — correct, and the reason
+                     * they cannot be enforced anywhere else.
+                     *
+                     * Note this cannot make a tool appear: an excluded tool never reaches `built` (the registry
+                     * removed it), and naming an excluded tool as preloaded does not resurrect it. Exclusion is a
+                     * permission and residency is a budget; the permission wins.
+                     */
+                    protect: (tool) => META_TOOLS.includes(tool.name) ||
+                        (manifest.toolPolicy?.preloaded ?? []).includes(tool.name) ||
+                        (tool.category !== undefined && (manifest.toolPolicy?.categories ?? []).includes(tool.category)),
+                });
+            const declared = budgetOutcome?.resident ?? built;
+            if (budgetOutcome !== undefined && (budgetOutcome.dropped.length > 0 || budgetOutcome.overBudget)) {
+                yield {
+                    type: "catalog.truncated",
+                    catalog: "tools",
+                    budgetTokens: budgetOutcome.budgetTokens,
+                    residentTokens: budgetOutcome.residentTokens,
+                    dropped: budgetOutcome.dropped,
+                    findable: declared.some((tool) => tool.name === "find_tools"),
+                    ...(budgetOutcome.overBudget ? { overBudget: true } : {}),
+                };
+            }
             const maxSteps = manifest.limits?.maxSteps ?? 8;
             const messageId = deriveRunMessageId(run.id);
             // A decision taken while the run was parked. Executed before the model gets another turn, so the
@@ -113,6 +229,46 @@ export const createDefaultEngine = (deps) => {
                 for (const event of questionEvents(answered, messages))
                     yield event;
             }
+            /**
+             * Inspection, before the model sees anything — REQ-046 (#205), AC-1.
+             *
+             * Placed after resumption so an approved side effect that already happened is not re-inspected, and
+             * *before* the tools are built so a refusal costs nothing: no provider call, no tool discovery, no spend.
+             *
+             * The subject is the newest user turn rather than the whole history. Re-inspecting history every turn
+             * would re-refuse a conversation over something already allowed, and a guardrail that changes its mind
+             * about the past makes a conversation impossible to continue.
+             */
+            const guardrails = deps.guardrails ?? [];
+            if (guardrails.length > 0) {
+                const latest = [...messages].reverse().find((m) => m.role === "user");
+                const decision = await applyInputGuardrails(guardrails, { text: latest ? turnText(latest) : "" }, context);
+                for (const record of decision.records)
+                    yield verdictEvent(record);
+                if (decision.outcome === "refused") {
+                    /**
+                     * The turn ends here, and it ends *visibly*.
+                     *
+                     * A text part rather than a thrown error: a refusal is a policy outcome, not a crash, and a run that
+                     * failed with a stack trace tells the person nothing and the operator the wrong thing. The model is
+                     * never called, which is what AC-3 asks for — "the turn does not proceed".
+                     */
+                    const partId = `${messageId}:guardrail:refused`;
+                    yield {
+                        type: "part.added",
+                        messageId,
+                        part: {
+                            id: partId,
+                            type: "text",
+                            schemaVersion: 1,
+                            createdAt: new Date(0).toISOString(),
+                            text: decision.message,
+                        },
+                    };
+                    yield { type: "run.completed" };
+                    return;
+                }
+            }
             /**
              * The tools the model may call, with execution routed through the approval loop.
              *
@@ -131,6 +287,58 @@ export const createDefaultEngine = (deps) => {
              * carried on and completed. The person's answer arrived for a run that was already over.
              */
             let pendingQuestion = null;
+            /**
+             * A connection a tool needed and the tenant does not have — task #264.
+             *
+             * Tracked exactly like `pendingApproval` and `pendingQuestion`, and for the same reason: the run has to
+             * stop on an *event* the worker understands rather than on an error the model would try to work around.
+             */
+            /**
+             * Turns a marked connection failure into a pause, or leaves it to fail — task #264.
+             *
+             * Three ways to end up failing rather than pausing, and each is deliberate:
+             *
+             * - the failure is not a connection gap at all
+             * - no `connectionConsent` is wired, so this deployment has no flow to send anybody to
+             * - the callback returns `null`, meaning *this provider* is token-only and there is no login URL
+             *
+             * All three fail, because the alternative is a run parked for ever on a consent screen nobody can reach.
+             */
+            const consentMarker = async (thrown, toolName) => {
+                const need = connectionNeedOf(thrown);
+                if (need === null || deps.connectionConsent === undefined)
+                    return null;
+                const offer = await deps.connectionConsent({ context, need: { ...need, toolName } });
+                if (offer === null)
+                    return null;
+                return {
+                    event: {
+                        type: "connection.requested",
+                        provider: need.provider,
+                        loginUrl: offer.loginUrl,
+                        scopes: offer.scopes,
+                        toolName,
+                        expiresAt: offer.expiresAt,
+                    },
+                    // Returned to the model, not thrown — the same choice the approval path makes. The tool call stays a
+                    // real part of the record with a real result, and the run pauses on the event rather than on an error
+                    // the model would try to work around.
+                    marker: {
+                        status: "connection_required",
+                        provider: need.provider,
+                        message: `${toolName} needs a ${need.provider} connection. The run is paused; do not retry.`,
+                    },
+                };
+            };
+            /**
+             * The formed event, not the parts.
+             *
+             * Storing the pieces and building the event at the check site fought control-flow analysis: the
+             * assignment happens inside a tool's `execute` closure, so the outer `let` narrows to `never` at the
+             * check and every property access errors. Holding the event itself needs no property access there, and
+             * reads more like `pendingApproval` — a value the emit site simply yields.
+             */
+            let pendingConnection = null;
             /**
              * Citation candidates a tool handed back this turn, waiting for the claims they ground — #165.
              *
@@ -139,6 +347,15 @@ export const createDefaultEngine = (deps) => {
              * the passage supports. Emitting at the tool call would produce citations supporting nothing.
              */
             const pendingCitations = [];
+            /**
+             * Guardrail verdicts on tool arguments, buffered — REQ-046 (#205), AC-2 and AC-4.
+             *
+             * Buffered for the same reason as the citations above: the inspection happens inside a tool's `execute`,
+             * which is a callback the model's stream invokes and not a generator, so it cannot yield. Dropping the
+             * records instead would satisfy the enforcement half of AC-2 and quietly fail AC-4 — the check would work
+             * and leave no trace, which is the combination that makes an incident unreconstructable.
+             */
+            const pendingVerdicts = [];
             const approvals = deps.approvals;
             /**
              * Every tool is wrapped, whether or not an approval gate is configured.
@@ -147,19 +364,86 @@ export const createDefaultEngine = (deps) => {
              * interception point at all — and a question raised by one of its tools could not be noticed. The gate
              * decides *approvals*; parking a run on a question is not its business.
              */
+            /**
+             * What each call actually ran, keyed by the provider's call id — task #210.
+             *
+             * `execute_tool` names its target, so the tool the model called and the action performed are two different
+             * things. The wrapper is the only place that knows both, and the events are emitted somewhere else, so the
+             * fact has to be carried across. Without it a `destructive` tool invoked through `execute_tool` appears in
+             * the audit trail as "execute_tool", which is not an answer to the question the trail exists to answer.
+             */
+            const ranByCall = new Map();
             const tools = declared.map((t) => ({
                 ...t,
-                execute: async (input) => {
+                execute: async (input, options) => {
+                    /**
+                     * What this call is allowed to tell us — task #210.
+                     *
+                     * The host's closure is what reaches the registry, so it is the only thing that can know a call
+                     * resolved to a different tool. `report` is how it says so, and the map is read where the events are
+                     * emitted.
+                     */
+                    const report = (fact) => {
+                        if (options?.toolCallId !== undefined)
+                            ranByCall.set(options.toolCallId, fact.ranToolName);
+                    };
+                    /**
+                     * A tool call is an output — AC-2.
+                     *
+                     * Before either branch below, so it applies whether or not an approval gate is configured, and
+                     * *before* the gate so a refused call never becomes an approval request: asking a person to approve
+                     * something that will not happen is how approving comes to feel meaningless.
+                     *
+                     * The refusal is returned as a tool *result* rather than thrown. The model then sees why its call did
+                     * not happen and can say so, which is the difference between a run that explains itself and one that
+                     * dies with a stack trace the person cannot act on.
+                     */
+                    if (guardrails.length > 0) {
+                        const decision = await applyOutputGuardrails(guardrails, { kind: "tool-call", toolName: t.name, input }, context);
+                        pendingVerdicts.push(...decision.records);
+                        if (decision.outcome === "refused") {
+                            return { refused: true, guardrail: decision.by, code: decision.code, message: decision.message };
+                        }
+                        // A redacted call runs with the redaction, not with what the model typed.
+                        if (decision.value.kind === "tool-call")
+                            input = decision.value.input;
+                    }
+                    /**
+                     * What a tool hands back is inspected too — AC-3.
+                     *
+                     * A tool result is content entering the model's context from outside the tenant, and it is the
+                     * likeliest source of personal data in a run: a document read by a tool contains whatever the document
+                     * contains. Checking arguments and not results would guard the direction data leaves and ignore the
+                     * direction it arrives.
+                     *
+                     * A refusal replaces the result rather than throwing, for the same reason as above: the model is told
+                     * why and can say so, instead of the run dying where the person cannot see the cause.
+                     */
+                    const inspectResult = async (output) => {
+                        if (guardrails.length === 0)
+                            return output;
+                        const decision = await applyOutputGuardrails(guardrails, { kind: "tool-result", toolName: t.name, output }, context);
+                        pendingVerdicts.push(...decision.records);
+                        if (decision.outcome === "refused") {
+                            return { refused: true, guardrail: decision.by, code: decision.code, message: decision.message };
+                        }
+                        return decision.value.kind === "tool-result" ? decision.value.output : output;
+                    };
                     if (approvals === undefined) {
                         try {
-                            return collectCitations(await t.execute(input), pendingCitations);
+                            return collectCitations(await inspectResult(await t.execute(input, { ...(options ?? {}), report })), pendingCitations);
                         }
                         catch (thrown) {
                             const parked = questionMarker(thrown, t.name);
-                            if (parked === null)
+                            if (parked !== null) {
+                                pendingQuestion = parked.interactionId;
+                                return parked.marker;
+                            }
+                            const consent = await consentMarker(thrown, t.name);
+                            if (consent === null)
                                 throw thrown;
-                            pendingQuestion = parked.interactionId;
-                            return parked.marker;
+                            pendingConnection = consent.event;
+                            return consent.marker;
                         }
                     }
                     const outcome = await approvals.runTool(context, run.id, { name: t.name, input });
@@ -175,6 +459,9 @@ export const createDefaultEngine = (deps) => {
                             message: `${t.name} needs human approval before it can run. The run is paused; do not retry.`,
                         };
                     }
+                    // The approval path reaches the registry itself, so the fact needs no host cooperation here.
+                    if (outcome.result.ranToolName !== undefined)
+                        report({ ranToolName: outcome.result.ranToolName });
                     if (!outcome.result.ok) {
                         // The registry flattens a delegate's throw into a result, so the question arrives here as a code.
                         const parked = questionMarker(outcome.result.error, t.name);
@@ -184,12 +471,14 @@ export const createDefaultEngine = (deps) => {
                         }
                         throw new AgentPlatformError(outcome.result.error);
                     }
-                    return collectCitations(outcome.result.data, pendingCitations);
+                    return collectCitations(await inspectResult(outcome.result.data), pendingCitations);
                 },
             }));
             let attempt = 1;
             for (;;) {
                 let emitted = 0;
+                // Whether this turn produced the structured answer a structured agent promises — #243.
+                let sawStructured = false;
                 const textParts = new Map();
                 const controller = new AbortController();
                 try {
@@ -227,6 +516,15 @@ export const createDefaultEngine = (deps) => {
                         ...(resolved.definition === undefined
                             ? {}
                             : { modelModalities: resolved.definition.inputModalities }),
+                        // Mapped from the manifest here, so the model layer stays free of any dependency on `agents/`.
+                        ...(manifest.responseFormat?.kind === "structured"
+                            ? { structuredOutput: { schema: manifest.responseFormat.schema } }
+                            : {}),
+                        // From the resolved model's own declaration — #247. Absent definition means send nothing, the same
+                        // rule `modelModalities` follows: a host that has not said what its model does has not said it caches.
+                        ...(resolved.definition?.capabilities?.promptCaching === undefined
+                            ? {}
+                            : { promptCaching: resolved.definition.capabilities.promptCaching }),
                         tools,
                         maxSteps,
                         abortSignal: controller.signal,
@@ -238,8 +536,10 @@ export const createDefaultEngine = (deps) => {
                             controller.abort();
                             return;
                         }
-                        for (const event of mapChunk(chunk, messageId, resolved, textParts)) {
+                        for (const event of mapChunk(chunk, messageId, resolved, textParts, ranByCall)) {
                             emitted += 1;
+                            if (event.type === "part.added" && event.part.type === "structured")
+                                sawStructured = true;
                             yield event;
                         }
                         // Raised by a tool call this turn. Stop here rather than letting the model keep going: the
@@ -257,6 +557,13 @@ export const createDefaultEngine = (deps) => {
                             yield { type: "question.requested", interactionId: asId(pendingQuestion) };
                             return;
                         }
+                        // The third stop — #264. The event carries the provider, the scopes and the URL, and **no secret**:
+                        // it is rendered in a UI and clicked by a person, so it goes wherever a screenshot goes.
+                        if (pendingConnection !== null) {
+                            controller.abort();
+                            yield pendingConnection;
+                            return;
+                        }
                     }
                     /**
                      * Citations last, grounding the claims that were actually written — #165.
@@ -270,6 +577,25 @@ export const createDefaultEngine = (deps) => {
                      * After the stream, so a citation cannot appear above text the reader is already looking at — the
                      * append-only property `citationViewModel` depends on.
                      */
+                    /**
+                     * A structured agent must have produced a structured answer — task #243 AC-2.
+                     *
+                     * `streamModelTurn` already validates and fails, so in the normal path this never fires. It fires for
+                     * a host that supplied its own `streamTurn`, and that is the case worth guarding: the guarantee a
+                     * consumer bought is "structured or an error", and if it depended solely on the shipped model layer
+                     * then any host replacing that layer would silently get prose again — the original defect, reachable
+                     * through a documented extension point.
+                     */
+                    if (manifest.responseFormat?.kind === "structured" && !sawStructured)
+                        throw new AgentPlatformError({
+                            code: "provider_error",
+                            message: `agent "${manifest.id}" asks for a structured response format and the turn produced none. ` +
+                                "The run fails rather than returning the turn's text, which would be prose presented as a " +
+                                "validated object.",
+                            retryable: true,
+                        });
+                    for (const record of pendingVerdicts.splice(0))
+                        yield verdictEvent(record);
                     if (deps.citations !== undefined && pendingCitations.length > 0) {
                         const claims = [...textParts.values()].map((t) => t.partId);
                         if (claims.length > 0) {
@@ -392,7 +718,9 @@ function* approvalEvents(resumed, messageId, messages) {
     });
 }
 /** Map one neutral chunk to zero or more engine events. Mutates `textParts` to accumulate deltas. */
-function* mapChunk(chunk, messageId, resolved, textParts) {
+function* mapChunk(chunk, messageId, resolved, textParts, 
+/** What each call resolved to, when it was not what the model named — task #210. */
+ranByCall = new Map()) {
     switch (chunk.type) {
         case "text-delta": {
             const existing = textParts.get(chunk.id);
@@ -425,6 +753,7 @@ function* mapChunk(chunk, messageId, resolved, textParts) {
             return;
         }
         case "tool-result": {
+            const ran = ranByCall.get(chunk.toolCallId);
             const part = {
                 id: `${chunk.toolCallId}:result`,
                 type: "tool-result",
@@ -432,10 +761,16 @@ function* mapChunk(chunk, messageId, resolved, textParts) {
                 createdAt: new Date(0).toISOString(),
                 toolCallId: asId(chunk.toolCallId),
                 toolName: chunk.toolName,
+                ...(ran === undefined ? {} : { ranToolName: ran }),
                 output: chunk.output,
                 truncated: false,
             };
-            yield { type: "tool.completed", toolCallId: asId(chunk.toolCallId), toolName: chunk.toolName };
+            yield {
+                type: "tool.completed",
+                toolCallId: asId(chunk.toolCallId),
+                toolName: chunk.toolName,
+                ...(ran === undefined ? {} : { ranToolName: ran }),
+            };
             yield { type: "part.added", messageId, part };
             return;
         }
@@ -445,6 +780,9 @@ function* mapChunk(chunk, messageId, resolved, textParts) {
                 inputTokens: chunk.usage.inputTokens,
                 outputTokens: chunk.usage.outputTokens,
                 cachedInputTokens: chunk.usage.cachedInputTokens,
+                // Carried only when the provider reported it, so a turn with no breakdown is distinguishable from a
+                // turn that wrote nothing — the same rule `imageCount` follows two lines down.
+                ...(chunk.usage.cacheWriteTokens === undefined ? {} : { cacheWriteTokens: chunk.usage.cacheWriteTokens }),
                 ...(chunk.usage.reasoningTokens !== undefined ? { reasoningTokens: chunk.usage.reasoningTokens } : {}),
                 // Counted at the send site (`nonTextCounts`), carried through so the ledger records it (#185).
                 ...(chunk.usage.imageCount !== undefined ? { imageCount: chunk.usage.imageCount } : {}),
@@ -455,6 +793,25 @@ function* mapChunk(chunk, messageId, resolved, textParts) {
             };
             return;
         }
+        case "structured-output": {
+            /**
+             * The validated answer of a structured agent — task #243.
+             *
+             * Emitted once, complete. `streamModelTurn` has already validated it against the schema and fails the turn
+             * if it does not conform, so reaching here means the value satisfies what the caller asked for. Nothing
+             * partial is ever emitted: a half-built object does not satisfy a schema, so streaming one would publish
+             * values that violate the contract.
+             */
+            const part = {
+                id: `${messageId}:structured`,
+                type: "structured",
+                schemaVersion: 1,
+                createdAt: new Date(0).toISOString(),
+                value: chunk.value,
+            };
+            yield { type: "part.added", messageId, part };
+            return;
+        }
         case "error":
             throw chunk.error instanceof Error ? chunk.error : new Error(String(chunk.error));
     }