@dynamicagents/plugins 0.12.0 → 0.13.0

package/dist/recall/index.js

@@ -1,181 +0,0 @@
-import { embedMany, tool } from "ai";
-import { z } from "zod";
-import { createWorkersAI } from "workers-ai-provider";
-import { definePlugin } from "@dynamicagents/core";
-import { gatewayLogFields, parseTurn, sessionText } from "@dynamicagents/core/agent";
-/**
- * `@dynamicagents/plugins/recall` — episodic memory over Cloudflare Vectorize.
- *
- * When the Session compacts, the raw messages it folds into a summary would
- * otherwise be lost. Core announces that moment (`onMessagesDisplaced`) because
- * core is what performs the lossy operation; this plugin is what does something
- * about it — embedding the displaced range and upserting it, so a `recall` tool
- * can later semantically search history that has scrolled out of the live
- * context window.
- *
- * Core carries **no embedding code at all**: no `Embed` type, no
- * `embeddingModelId`, no recall config. Putting any of it there fixes the shape
- * of embedding for every future plugin — one model, one dimension,
- * `string[] → number[][]` — and lets `ModelConfig` say only "the agent has an
- * embedding model" when the true statement is "*this plugin* uses this embedding
- * model". So the whole embedding path lives here.
- *
- * The namespace is always bound in code from the caller's verified identity,
- * never model input, so one caller can never read another's archive.
- */
-/** Workers-AI embedding model. 1024-dim/cosine, matching the Vectorize index. */
-const DEFAULT_EMBEDDING_MODEL_ID = "@cf/baai/bge-m3";
-/** Matches to return from a search. */
-const DEFAULT_TOP_K = 5;
-/**
- * Stored-snippet cap. Vectorize allows roughly 10 KiB of metadata per vector,
- * and the snippet is nearly all of it — a message longer than this is truncated
- * rather than costing the whole upsert.
- */
-const DEFAULT_METADATA_TEXT_MAX = 2000;
-/**
- * Build the Vectorize vectors for a batch of archived messages. Pure:
- * `embeddings` are supplied 1:1 with `messages` (both already filtered to
- * non-empty text). The vector `id` is the message's own id, so re-archiving on a
- * compaction retry is an idempotent upsert; `<turn>` provenance is lifted into
- * metadata when present.
- */
-export function toRecallVectors(messages, namespace, embeddings, metadataTextMax = DEFAULT_METADATA_TEXT_MAX) {
-    return messages.map((m, i) => {
-        const text = sessionText(m);
-        const metadata = {
-            role: m.role,
-            text: text.slice(0, metadataTextMax)
-        };
-        const turn = parseTurn(text);
-        if (turn) {
-            metadata.author = turn.from;
-            metadata.authorId = turn.id;
-            metadata.channel = turn.channel;
-            metadata.at = turn.at;
-        }
-        return { id: m.id, namespace, values: embeddings[i], metadata };
-    });
-}
-/**
- * Archive a range of displaced messages into Vectorize. Embeds the non-empty
- * texts in one batch and upserts them under `namespace`. No-op on empty input.
- */
-export async function archiveMessages(index, namespace, messages, embed, metadataTextMax = DEFAULT_METADATA_TEXT_MAX) {
-    const withText = messages.filter((m) => sessionText(m).trim().length > 0);
-    if (withText.length === 0)
-        return;
-    const embeddings = await embed(withText.map((m) => sessionText(m)));
-    await index.upsert(toRecallVectors(withText, namespace, embeddings, metadataTextMax));
-}
-/**
- * Semantically search this instance's archive. Embeds the query and returns the
- * top matches within `namespace`, mapping each vector's metadata to a compact
- * {@link RecallResult}. Constrained to `namespace` — never a caller-supplied one.
- */
-export async function recallSearch(index, namespace, query, embed, topK = DEFAULT_TOP_K) {
-    const [vector] = await embed([query]);
-    if (!vector)
-        return [];
-    const { matches } = await index.query(vector, {
-        namespace,
-        topK,
-        returnMetadata: "all"
-    });
-    return matches.map((match) => {
-        const md = (match.metadata ?? {});
-        const result = {
-            score: match.score,
-            role: md.role ?? "unknown",
-            text: md.text ?? ""
-        };
-        if (md.author)
-            result.author = md.author;
-        if (md.authorId)
-            result.authorId = md.authorId;
-        if (md.channel)
-            result.channel = md.channel;
-        if (md.at)
-            result.at = md.at;
-        return result;
-    });
-}
-export function recall(config) {
-    const { ai, index, namespace, aiGatewayId, agentName, embeddingModelId = DEFAULT_EMBEDDING_MODEL_ID, topK = DEFAULT_TOP_K, metadataTextMax = DEFAULT_METADATA_TEXT_MAX } = config;
-    /**
-     * Built on first use, never at module scope. Cloudflare evaluates module scope
-     * during `wrangler deploy` to validate the new version, and bindings are not
-     * populated at that point — constructing eagerly makes `createWorkersAI` throw
-     * "you must provide either a binding or credentials".
-     *
-     * The gateway goes on the embedding model and never on the provider — see
-     * core's Workers AI runtime for why setting it on both discards the model's.
-     * Only `agent` and `phase` are known here: one call embeds a whole displaced
-     * range, which can span channels, or a query the model wrote.
-     */
-    let provider;
-    const embeddingSettings = aiGatewayId
-        ? {
-            gateway: {
-                id: aiGatewayId,
-                ...gatewayLogFields({ agent: agentName, phase: "embed" })
-            }
-        }
-        : {};
-    const embed = config.embed ??
-        (async (texts) => {
-            if (texts.length === 0)
-                return [];
-            provider ??= createWorkersAI({ binding: ai });
-            const { embeddings } = await embedMany({
-                model: provider.embedding(embeddingModelId, embeddingSettings),
-                values: texts
-            });
-            return embeddings;
-        });
-    return definePlugin({
-        key: "recall",
-        /**
-         * Offered only once this caller's history has actually been compacted.
-         *
-         * Before the first compaction the archive is empty by construction, and a
-         * tool whose only possible answer is "nothing here yet" costs the model a
-         * call to discover that — plus the tokens to describe it, every round.
-         */
-        mainAgentTools: async (ctx) => {
-            if ((await ctx.session.getCompactions()).length === 0)
-                return {};
-            return {
-                recall: tool({
-                    description: "Search your own older conversation history with this caller that has scrolled out of the live context window (it was summarized during compaction). Use this to recall specific past details — quotes, decisions, facts — that you no longer have verbatim. Returns the most semantically similar archived messages with their author/channel/timestamp when known.",
-                    inputSchema: z.object({
-                        query: z
-                            .string()
-                            .describe("What to look for in the archived history"),
-                        limit: z
-                            .number()
-                            .int()
-                            .min(1)
-                            .max(20)
-                            .optional()
-                            .describe(`Max number of matches to return (default ${topK})`)
-                    }),
-                    // The index, the namespace and the embedder all come from the closure.
-                    // The model can only ever supply a query string and a count.
-                    execute: async ({ query, limit }) => ({
-                        results: await recallSearch(index, namespace(), query, embed, limit ?? topK)
-                    })
-                })
-            };
-        },
-        capability: "You can search your own older history with this caller — everything that has scrolled out of your live context window and been summarized. Use `recall` when you need a specific past detail verbatim (a quote, a decision, a number) rather than the gist you already have in your summary. It searches by meaning, so describe what you are looking for rather than guessing exact words.",
-        /**
-         * Compaction is about to fold these into a summary; embed and store them
-         * first. Failures are the runtime's to swallow — it fans out with
-         * `allSettled` and never lets a listener abort compaction, because history
-         * must still shorten when a side store is briefly unavailable.
-         */
-        onMessagesDisplaced: (messages) => archiveMessages(index, namespace(), messages, embed, metadataTextMax),
-        requires: { bindings: ["VECTORIZE"] }
-    });
-}

package/dist/repo/tools-forge.d.ts

@@ -1,4 +0,0 @@
-import type { ToolSet } from "ai";
-import type { RepoContext } from "./context.js";
-/** The forge's REST surface: pull requests, issues and their comments. */
-export declare function forgeTools(ctx: RepoContext): ToolSet;

package/dist/triage/index.d.ts

@@ -1,360 +0,0 @@
-import type { LanguageModel } from "ai";
-import { z } from "zod";
-import type { AgentPlugin } from "@dynamicagents/core";
-import type { SessionMessage } from "@dynamicagents/core/agent";
-/**
- * The classifier's output. The booleans are **not** metadata for the caller —
- * only `should_reply` is ever read. They exist to shape the generation itself:
- * constrained decoding fills properties in schema order, so declaring them ahead
- * of `should_reply` forces the model to commit to the sub-judgements that
- * determine the answer — *who is this for*, and *do I have something worth
- * adding* — before it can name a verdict. Reordering these fields, or dropping
- * one, changes what the model reasons about; it is not cosmetic.
- *
- * `reason` comes last, after the verdict, on purpose: generated afterwards it
- * justifies the decision rather than steering it, so a logged reason can never
- * contradict the `should_reply` it explains. That is what makes it worth reading
- * when a misclassification needs debugging.
- */
-export declare const triageSchema: z.ZodObject<{
-    for_other_people: z.ZodBoolean;
-    for_another_agent: z.ZodBoolean;
-    can_contribute: z.ZodBoolean;
-    should_reply: z.ZodBoolean;
-    reason: z.ZodString;
-}, z.core.$strip>;
-export type TriageVerdict = z.infer<typeof triageSchema>;
-/**
- * The tuning half of {@link TriageConfig}: plain values, no bindings.
- *
- * Declare these once in a config module and spread them at the call site — see
- * `RecallTuning` for why enumerating each field is a liability rather than just
- * noise.
- */
-export interface TriageTuning {
-    /**
-     * AI Gateway id. Pass the host's **resolved** value
-     * (`PluginHost.aiGatewayId`), so classify calls stay correlated with chat calls
-     * in one gateway.
-     */
-    aiGatewayId?: string;
-    /**
-     * The `agent` key on the classifier's AI Gateway log rows. Pass the host's
-     * `PluginHost.agentName`, for the reason given on {@link aiGatewayId}.
-     */
-    agentName?: string;
-    /** Workers-AI id for the classifier. Defaults to a small, fast model. */
-    modelId?: string;
-    /** Trailing messages the classifier sees. Defaults to 12. */
-    historyMessages?: number;
-    /** Per-message char cap in the prompt. Defaults to 500. */
-    messageMaxChars?: number;
-}
-export interface TriageConfig extends TriageTuning {
-    /** The `AI` binding. Read lazily — see {@link triage}. */
-    ai: Ai;
-    /** Test override; skips the provider entirely. */
-    model?: LanguageModel;
-}
-export interface TriagePromptOptions {
-    historyMessages?: number;
-    messageMaxChars?: number;
-}
-/**
- * Build the classifier prompt from the tail of the conversation.
- *
- * A bare message is frequently unclassifiable — "yes", "thanks", "and the second
- * one?" only resolve against what came before — and the drift being fixed is
- * *only* visible in context, where the classifier can see the agent has been
- * talking and that the speaker has since turned to someone else.
- *
- * Exported for its own tests: it is pure, so the prompt can be asserted without
- * an LLM.
- */
-export declare function buildTriagePrompt(history: SessionMessage[], options?: TriagePromptOptions): string;
-/**
- * Classify whether the agent should reply to the newest message in `history`.
- *
- * **Fails open.** Every error is caught here and answered `true`, because the
- * two mistakes are not symmetric: a wrong reply is noise the user can see and
- * ignore, while a wrong silence is invisible — the person who needed the agent
- * simply never hears back and has no way to tell that anything happened. A
- * triage outage must therefore degrade to the previous behaviour (let the loop
- * decide), never to a silent agent.
- *
- * Only `should_reply` is read; the other fields exist to steer the generation
- * (see {@link triageSchema}) and are logged, not re-derived in code.
- */
-export declare function shouldReply(model: LanguageModel, history: SessionMessage[], options?: TriagePromptOptions): Promise<boolean>;
-export declare function triage(config: TriageConfig): AgentPlugin;
-/** The tool the model calls to end a turn without replying. */
-export declare const NO_REPLY_TOOL_NAME = "no_reply";
-/**
- * Tool result when a `no_reply` call is ignored. This is only ever read by the
- * model in one case: it has already sent something this turn (so the tool was
- * withdrawn) yet named it anyway — the call is ignored and it must finish with a
- * reply. When a `no_reply` call is instead honoured it ends the turn, and this
- * result is discarded unread.
- */
-export declare const NO_REPLY_IGNORED = "Ignored: you have already sent a message this turn \u2014 finish with a reply.";
-/**
- * End the turn without replying — the *late* counterpart to the pre-turn gate.
- * The agent looks something up, concludes there is nothing worth adding, and
- * declines.
- *
- * Deliberately an ordinary tool with an ordinary no-op `execute`: the loop, not
- * the tool, decides what a `no_reply` call means (see {@link isNoReplyTurn}).
- * Two things here are load-bearing:
- *
- * - **`execute` must exist.** Once the agent has spoken the tool is withdrawn,
- *   but the model can still name it (the SDK resolves calls against the
- *   unfiltered map); that call is ignored and the loop must continue to a real
- *   reply. `generateText` only continues while every tool call in a step
- *   produced an output, so without `execute` that step would halt with no reply
- *   text and surface as a failure. Executing normally keeps the counts equal.
- * - **`reason` must stay optional.** A required field the model omits makes the
- *   SDK mark the call invalid and skip execution, halting the loop the same way.
- *
- * Wiring is the loop's: offer this tool until the agent has spoken, withdraw it
- * after, and stop the run when {@link isNoReplyTurn} holds.
- */
-export declare const noReplyTool: ({
-    title?: string;
-    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
-    metadata?: import("@ai-sdk/provider").JSONObject;
-    inputSchema: import("ai").FlexibleSchema<{
-        reason?: string | undefined;
-    }>;
-    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
-    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
-        reason?: string | undefined;
-    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
-    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
-    onInputDelta?: ((options: {
-        inputTextDelta: string;
-    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
-    onInputAvailable?: ((options: {
-        input: {
-            reason?: string | undefined;
-        };
-    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
-    toModelOutput?: ((options: {
-        toolCallId: string;
-        input: {
-            reason?: string | undefined;
-        };
-        output: string;
-    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
-} & {
-    outputSchema?: import("ai").FlexibleSchema<string> | undefined;
-    execute: import("ai").ToolExecuteFunction<{
-        reason?: string | undefined;
-    }, string, NoInfer<import("@ai-sdk/provider-utils").Context>>;
-} & {
-    description?: string | ((options: {
-        context: NoInfer<import("@ai-sdk/provider-utils").Context>;
-        experimental_sandbox?: import("ai").Experimental_SandboxSession;
-    }) => string) | undefined;
-    strict?: boolean;
-    inputExamples?: {
-        input: NoInfer<{
-            reason?: string | undefined;
-        }>;
-    }[] | undefined;
-    id?: never;
-    isProviderExecuted?: never;
-    args?: never;
-    supportsDeferredResults?: never;
-} & {
-    type?: undefined | "function";
-} & {
-    execute: import("ai").ToolExecuteFunction<{
-        reason?: string | undefined;
-    }, string, NoInfer<import("@ai-sdk/provider-utils").Context>>;
-}) | ({
-    title?: string;
-    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
-    metadata?: import("@ai-sdk/provider").JSONObject;
-    inputSchema: import("ai").FlexibleSchema<{
-        reason?: string | undefined;
-    }>;
-    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
-    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
-        reason?: string | undefined;
-    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
-    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
-    onInputDelta?: ((options: {
-        inputTextDelta: string;
-    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
-    onInputAvailable?: ((options: {
-        input: {
-            reason?: string | undefined;
-        };
-    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
-    toModelOutput?: ((options: {
-        toolCallId: string;
-        input: {
-            reason?: string | undefined;
-        };
-        output: string;
-    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
-} & {
-    outputSchema?: import("ai").FlexibleSchema<string> | undefined;
-    execute: import("ai").ToolExecuteFunction<{
-        reason?: string | undefined;
-    }, string, NoInfer<import("@ai-sdk/provider-utils").Context>>;
-} & {
-    description?: string | ((options: {
-        context: NoInfer<import("@ai-sdk/provider-utils").Context>;
-        experimental_sandbox?: import("ai").Experimental_SandboxSession;
-    }) => string) | undefined;
-    strict?: boolean;
-    inputExamples?: {
-        input: NoInfer<{
-            reason?: string | undefined;
-        }>;
-    }[] | undefined;
-    id?: never;
-    isProviderExecuted?: never;
-    args?: never;
-    supportsDeferredResults?: never;
-} & {
-    type: "dynamic";
-} & {
-    execute: import("ai").ToolExecuteFunction<{
-        reason?: string | undefined;
-    }, string, NoInfer<import("@ai-sdk/provider-utils").Context>>;
-}) | ({
-    title?: string;
-    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
-    metadata?: import("@ai-sdk/provider").JSONObject;
-    inputSchema: import("ai").FlexibleSchema<{
-        reason?: string | undefined;
-    }>;
-    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
-    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
-        reason?: string | undefined;
-    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
-    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
-    onInputDelta?: ((options: {
-        inputTextDelta: string;
-    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
-    onInputAvailable?: ((options: {
-        input: {
-            reason?: string | undefined;
-        };
-    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
-    toModelOutput?: ((options: {
-        toolCallId: string;
-        input: {
-            reason?: string | undefined;
-        };
-        output: string;
-    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
-} & {
-    outputSchema?: import("ai").FlexibleSchema<string> | undefined;
-    execute: import("ai").ToolExecuteFunction<{
-        reason?: string | undefined;
-    }, string, NoInfer<import("@ai-sdk/provider-utils").Context>>;
-} & {
-    type: "provider";
-    id: `${string}.${string}`;
-    args: Record<string, unknown>;
-    description?: never;
-    strict?: never;
-    inputExamples?: never;
-} & {
-    isProviderExecuted: false;
-    supportsDeferredResults?: never;
-} & {
-    execute: import("ai").ToolExecuteFunction<{
-        reason?: string | undefined;
-    }, string, NoInfer<import("@ai-sdk/provider-utils").Context>>;
-}) | ({
-    title?: string;
-    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
-    metadata?: import("@ai-sdk/provider").JSONObject;
-    inputSchema: import("ai").FlexibleSchema<{
-        reason?: string | undefined;
-    }>;
-    contextSchema?: import("ai").FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
-    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
-        reason?: string | undefined;
-    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
-    onInputStart?: ((options: import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
-    onInputDelta?: ((options: {
-        inputTextDelta: string;
-    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
-    onInputAvailable?: ((options: {
-        input: {
-            reason?: string | undefined;
-        };
-    } & import("ai").ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
-    toModelOutput?: ((options: {
-        toolCallId: string;
-        input: {
-            reason?: string | undefined;
-        };
-        output: string;
-    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
-} & {
-    outputSchema?: import("ai").FlexibleSchema<string> | undefined;
-    execute: import("ai").ToolExecuteFunction<{
-        reason?: string | undefined;
-    }, string, NoInfer<import("@ai-sdk/provider-utils").Context>>;
-} & {
-    type: "provider";
-    id: `${string}.${string}`;
-    args: Record<string, unknown>;
-    description?: never;
-    strict?: never;
-    inputExamples?: never;
-} & {
-    isProviderExecuted: true;
-    supportsDeferredResults?: boolean;
-} & {
-    execute: import("ai").ToolExecuteFunction<{
-        reason?: string | undefined;
-    }, string, NoInfer<import("@ai-sdk/provider-utils").Context>>;
-});
-/**
- * What the agent is told about {@link noReplyTool}, as a system-prompt suffix.
- *
- * It lives here rather than in a host's prompt file for the same reason a subtask
- * type carries its own `capability`: everything the model is told about a
- * capability is declared by whatever owns that capability, so uninstalling the
- * plugin takes its advice with it. A host describing a `no_reply` tool it no
- * longer installs is the exact drift those fields exist to end.
- *
- * Not a `capability` on the plugin, though, and the distinction is the design.
- * `capability` is rendered into the soul once and is true for the whole
- * conversation; this has to be **withdrawn mid-turn**, the moment the agent
- * speaks, in the same `prepareStep` that withdraws the tool. Advice for a tool
- * that is no longer on the call is worse than no advice — so the loop injects it,
- * and the loop is what knows when.
- */
-export declare const NO_REPLY_GUIDANCE: string;
-/** The only part of a `StepResult` the no-reply predicates read. */
-type ToolCallingStep = {
-    toolCalls: ReadonlyArray<{
-        toolName: string;
-    }>;
-};
-/** Whether a step calls `no_reply` at all — on its own or beside other tools. */
-export declare function stepCallsNoReply(step: ToolCallingStep): boolean;
-/**
- * Whether a run declined to reply: the agent has **not sent anything this turn**
- * (`!repliedAny`) and its final step called `no_reply`. A `no_reply` call ends
- * the turn the moment it appears — even beside another tool, which still runs
- * but whose result is discarded — so the first step to call it is the last. A
- * `no_reply` after the agent already streamed content is the one thing ignored.
- *
- * `!repliedAny` is the runtime guard that lets `no_reply` be a *late* decision
- * while still forbidding it once the agent has spoken. Hiding the tool from the
- * model merely hides it; the SDK still resolves a tool call against the full,
- * unfiltered map, so a model that names `no_reply` after speaking executes it
- * happily — this flag is what stops that from discarding a turn the user has
- * already seen.
- */
-export declare function isNoReplyTurn(repliedAny: boolean, steps: readonly ToolCallingStep[]): boolean;
-export {};