Call from TypeScript

Once your agent is running behind the API, any TypeScript application can call it using AgentFlowClient. The client handles HTTP requests, message formatting, and optional streaming.

Prerequisites

Keep the API server running from the previous page:

agentflow api --host 127.0.0.1 --port 8000

Install the client

In your TypeScript or Node.js project:

npm install @10xscale/agentflow-client

Invoke the agent

Create call-agent.ts:

import { AgentFlowClient, Message } from "@10xscale/agentflow-client";

const client = new AgentFlowClient({
  baseUrl: "http://127.0.0.1:8000",
});

const result = await client.invoke(
  [Message.text_message("What is the weather in Tokyo?")],
  {
    config: {
      thread_id: "ts-beginner-demo",
    },
  },
);

const reply = result.messages.at(-1);
console.log(reply?.text());

Run it (using tsx or your project’s TypeScript runner):

npx tsx call-agent.ts

Expected output:

The weather in Tokyo is sunny and 22°C.

Multi-turn conversation

Reuse the same thread_id to continue the conversation. Each call adds to the conversation history on the server side:

const THREAD = "ts-multi-turn-demo";

// First message
const first = await client.invoke(
  [Message.text_message("My name is Alex.")],
  { config: { thread_id: THREAD } },
);
console.log(first.messages.at(-1)?.text());

// Second message — server remembers the thread
const second = await client.invoke(
  [Message.text_message("What is my name?")],
  { config: { thread_id: THREAD } },
);
console.log(second.messages.at(-1)?.text());

Expected output:

Nice to meet you, Alex!
Your name is Alex.

Stream responses

For a better UX, stream the response instead of waiting for the full reply:

const stream = client.stream(
  [Message.text_message("Tell me a short story about a robot.")],
  { config: { thread_id: "ts-stream-demo" } },
);

for await (const chunk of stream) {
  if (chunk.event === "message" && chunk.message) {
    process.stdout.write(chunk.message.text());
  }
}
console.log(); // newline after stream ends

What the client sends

AgentFlowClient posts to POST /v1/graph/invoke (or /v1/graph/stream for streaming). The Message.text_message helper creates the same message shape used by the Python API.

sequenceDiagram
  participant TS as TypeScript app
  participant Client as AgentFlowClient
  participant API as 10xGraph API
  participant Graph as Python graph

  TS->>Client: invoke([messages], config)
  Client->>API: POST /v1/graph/invoke
  API->>Graph: run with thread state
  Graph-->>API: assistant messages
  API-->>Client: JSON response
  Client-->>TS: result.messages

Add authentication

If your API server is configured with a JWT secret, pass a bearer token:

const client = new AgentFlowClient({
  baseUrl: "http://127.0.0.1:8000",
  headers: {
    Authorization: `Bearer ${yourToken}`,
  },
});

What you learned

• Install @10xscale/agentflow-client and create an AgentFlowClient with your API URL.
• Use client.invoke for a full response or client.stream for incremental chunks.
• Pass the same thread_id across calls to maintain conversation history.
• Add authentication headers to the client constructor when the API requires them.

What you built

You have completed the beginner path. Your agent can now:

• Call a language model with a system prompt
• Use tools to retrieve external information
• Persist multi-turn conversations with a checkpointer
• Serve requests over HTTP
• Be tested in the hosted playground
• Be called from TypeScript

Next steps

• Core concepts — understand how the pieces fit together at scale (Concepts)
• Add a real checkpointer — replace InMemoryCheckpointer with Postgres for production (Checkpointing guide)
• Python library reference — explore the full StateGraph and Agent API (Reference)