Migrating from LangChain

// Before — LangChain
import { ChatPromptTemplate } from "@langchain/core/prompts";
import { RunnableSequence } from "@langchain/core/runnables";

const chain = RunnableSequence.from([
  { context: retriever, question: (input) => input.question },
  promptTemplate,
  llm,
]);

// After — wrap the retriever as a defineTool
import { defineTool } from "@pleach/core";

export const retrieveDocs = defineTool({
  name: "retrieve_docs",
  description: "Retrieve relevant documents for a query.",
  inputSchema: z.object({
    query: z.string().min(1),
    k:     z.number().int().min(1).max(20).default(5),
  }),
  async execute(input, ctx) {
    const docs = await retriever.invoke(input.query, {
      configurable: { k: input.k },
      signal:       ctx.signal,
    });
    return { docs: docs.map((d) => ({
      pageContent: d.pageContent,
      metadata:    d.metadata,
    })) };
  },
});

// Before — agent with chain
import { createOpenAIFunctionsAgent, AgentExecutor } from "langchain/agents";

const agent = await createOpenAIFunctionsAgent({
  llm, tools: [retrieveDocs, searchDb],
  prompt: agentPromptTemplate,
});
const executor = new AgentExecutor({ agent, tools: [...] });

const result = await executor.invoke({ input: "What is X?" });

// After
import { SessionRuntime, AiSdkProvider } from "@pleach/core";

const runtime = new SessionRuntime({
  provider: new AiSdkProvider({ model: openai("gpt-4o") }),
  storage,
  userId,
});

const session = await runtime.createSession({
  tools: { enabled: ["retrieve_docs", "search_db"] },
});

for await (const event of runtime.executeMessage(session.id, "What is X?")) {
  // stream events
}

// Before — BaseCallbackHandler
class MyHandler extends BaseCallbackHandler {
  name = "my-handler";

  async handleLLMStart(llm, prompts) {
    metrics.increment("llm.starts");
  }

  async handleLLMEnd(output) {
    metrics.timing("llm.tokens", output.llmOutput?.tokenUsage?.totalTokens);
  }

  async handleToolStart(tool, input) {
    metrics.increment("tool.starts", { name: tool.name });
  }
}

// After — tool starts arrive as `tool.started` StreamEvents on the
// executeMessage() iterable (they are stream events, not emitter events)
for await (const event of runtime.executeMessage(sessionId, input)) {
  if (event.type === "tool.started") {
    metrics.increment("tool.starts", { name: event.toolCall.name });
  }
}

// The audit ledger is the per-LLM-call surface. Wrap your ledger
// adapter to also emit metrics:
class MetricsAwareLedger implements ProviderDecisionLedger {
  constructor(private primary: ProviderDecisionLedger) {}
  async recordCall(call: AuditableCall) {
    metrics.increment("llm.calls", { model: call.call.model });
    metrics.timing("llm.latency", call.outcome.latencyMs);
    return this.primary.recordCall(call);
  }
}

// Before
const memory = new ConversationBufferMemory({ returnMessages: true });
await memory.saveContext({ input: userInput }, { output: assistantOutput });
const { history } = await memory.loadMemoryVariables({});

// After
// The runtime persists messages automatically via the storage adapter.
// Read history via:
const session = await runtime.sessions.find(sessionId);
const history = session?.state.messages ?? [];