Anatomy of an agent

import { connectAgent } from "@trytilde/sdk";
import { respond } from "./agent.js";

// `tilde deploy` loads this module to find the agent's prompts,
// tools, and skills. Export what it should register.
export { agent } from "./agent.js";

// Dial out to Tilde. `connectAgent` reads TILDE_GATEWAY_URL and
// TILDE_DEPLOYMENT_TOKEN, opens an outbound HTTP/2 stream, and
// sends ready heartbeats. This process listens on no port.
// Under `tilde deploy`, it starts nothing.
const connection = connectAgent({
  // Tilde calls `run` once for each invocation, with a fresh
  // context.
  run: respond,

  onRegistered: (registration) =>
    console.log("Agent is ready", registration.deploymentId),
});

// On shutdown, stop taking work and let active invocations
// finish and report. Your orchestrator sends SIGTERM during a
// rollout.
for (const signal of ["SIGINT", "SIGTERM"] as const)
  process.once(signal, () => void connection.close());

import { inference, type AgentContext } from "@trytilde/sdk";
import {
  convertToAiSdkMessages,
  tildeAiSdk,
  tildeCallOptions,
} from "@trytilde/sdk-vercel-ai-node";
import { createOpenAI } from "@ai-sdk/openai";
import {
  APICallError,
  ToolLoopAgent,
  convertToModelMessages,
  stepCountIs,
} from "ai";

// `inference` returns a base URL for Tilde's inference gateway
// and a placeholder API key. The gateway swaps in the real
// provider credential, so this process holds no key. Each
// request resolves to the invocation that makes it.
const openai = createOpenAI(inference("openai/production"));

// A plain AI SDK agent, defined once. `tilde deploy` registers
// its instructions as a versioned prompt.
export const agent = new ToolLoopAgent({
  id: "support-agent",
  instructions: [
    "You are a support assistant.",
    "Use the current channel tools to respond to the latest message.",
    "Model text is private and is not delivered to the user.",
  ].join(" "),
  model: openai.responses("gpt-4o-mini"),
  // Let the model call tools, read results, and call again.
  stopWhen: stepCountIs(8),
  maxOutputTokens: 600,
  // Record model calls in the Tracing tab.
  experimental_telemetry: { isEnabled: true, functionId: "support-agent" },
  // Lets each call carry Tilde's tools, skills, and new input.
  ...tildeCallOptions,
});

// Handle one invocation.
export async function respond(ctx: AgentContext) {
  try {
    // 1. Load the conversation from Tilde, and convert it into
    //    AI SDK messages. Attachments are downloaded for you.
    const history = await ctx.message.history();
    const messages = await convertToAiSdkMessages({
      messages: history.items,
      context: ctx,
    });

    // 2. Call the model. `tildeAiSdk` adds the channel's tools,
    //    such as sendMessage, the agent's Tilde tools, and its
    //    skills. Each tool call runs through the gateway, which
    //    checks the agent's capabilities and records it. It also
    //    stops the call when a user interrupts or an operator
    //    stops the run.
    await agent.generate({
      messages: await convertToModelMessages(messages),
      ...tildeAiSdk(ctx),
    });
  } catch (error) {
    // Provider error bodies can contain sensitive details.
    // Log only the status.
    const status = APICallError.isInstance(error)
      ? error.statusCode
      : undefined;
    if (ctx.signal.aborted) console.warn("Invocation cancelled");
    else console.error("Invocation failed", { status });
    const suffix = status ? ` (${status})` : "";
    throw new Error(`Agent run failed${suffix}`);
  }
}

FROM node:22-slim AS build
WORKDIR /app
COPY package.json pnpm-lock.yaml ./
RUN corepack enable && pnpm install --frozen-lockfile
COPY . .
RUN pnpm build

FROM node:22-slim
WORKDIR /app
ENV NODE_ENV=production
COPY --from=build /app/node_modules ./node_modules
COPY --from=build /app/dist ./dist
USER node
# No EXPOSE: the agent only dials out.
CMD ["node", "dist/index.js"]