#Deep Agents

import { createDeepAgent } from "deepagents";
import { tool } from "langchain";
import * as z from "zod";

const searchDocs = tool(async ({ query }) => `"${query}" 검색 결과: ...`, {
  name: "search_docs",
  description: "사내 기술 문서를 검색한다",
  schema: z.object({ query: z.string() }),
});

const agent = createDeepAgent({
  model: "anthropic:claude-sonnet-4-6",
  tools: [searchDocs],
  systemPrompt: "너는 사내 기술 리서처다. 조사 결과는 /report.md 에 정리한다.",
});

const result = await agent.invoke({
  messages: [{ role: "user", content: "우리 서비스의 인증 방식 세 가지를 비교하는 보고서를 써줘" }],
});

console.log(result.todos);                  // 에이전트가 세운 계획과 진행 상태
console.log(Object.keys(result.files));     // 가상 파일시스템에 만든 파일
console.log(result.messages.at(-1)?.text);  // 최종 답변

// result.todos 예시
[
  { content: "인증 방식 후보 조사", status: "completed" },
  { content: "방식별 장단점 표 작성", status: "in_progress" },
  { content: "보고서 초안 작성", status: "pending" },
]

import { createDeepAgent, CompositeBackend, StateBackend, StoreBackend, FilesystemBackend } from "deepagents";
import { InMemoryStore } from "@langchain/langgraph";

// 로컬 디렉터리에 가두기 — virtualMode: true 가 핵심
const localAgent = createDeepAgent({
  backend: new FilesystemBackend({ rootDir: "./workspace", virtualMode: true }),
});

// 기본은 스레드 임시 공간, /memories/ 아래만 스레드를 넘어 영구 보관
const store = new InMemoryStore();
const agent = createDeepAgent({
  store,
  backend: new CompositeBackend(new StateBackend(), {
    "/memories/": new StoreBackend({ store, namespace: () => ["users", "user-123"] }),
  }),
});

const agent = createDeepAgent({
  permissions: [
    { operations: ["read", "write"], paths: ["/workspace/**"] },          // 허용
    { operations: ["read", "write"], paths: ["/**/.env"], mode: "deny" },
    { operations: ["read", "write"], paths: ["/**"], mode: "deny" },      // 마지막 빗장
  ],
});

import { createDeepAgent } from "deepagents";
import { DenoSandbox } from "@langchain/deno";

const sandbox = await DenoSandbox.create({ memoryMb: 1024, lifetime: "10m" });

try {
  const agent = createDeepAgent({
    systemPrompt: "너는 샌드박스를 가진 TypeScript 코딩 어시스턴트다.",
    backend: sandbox,
  });
  await agent.invoke({
    messages: [{ role: "user", content: "Deno.serve 로 HTTP 서버를 만들고 curl 로 테스트해줘" }],
  });
} finally {
  await sandbox.close();
}

import { createDeepAgent } from "deepagents";
import { ChatAnthropic } from "@langchain/anthropic";
import { initChatModel } from "langchain";

// 1) "공급자:모델" 문자열
const a = createDeepAgent({ model: "anthropic:claude-sonnet-4-6" });

// 2) 공급자 클래스 — 재시도·타임아웃 등 세부 설정
const b = createDeepAgent({
  model: new ChatAnthropic({
    model: "claude-sonnet-4-6",
    maxRetries: 10,     // 불안정한 네트워크면 늘림
    timeout: 120_000,
  }),
});

// 3) initChatModel — 설정으로 공급자를 바꿀 때
const c = createDeepAgent({ model: await initChatModel(process.env.MODEL ?? "anthropic:claude-sonnet-4-6") });

import { tool } from "langchain";
import * as z from "zod";

const internetSearch = tool(
  async ({ query, maxResults }) => {
    const results = await mySearchClient.search(query, { limit: maxResults }); // 검색 API 호출 (예시)
    return JSON.stringify(results);
  },
  {
    name: "internet_search",
    description: "웹 검색을 실행한다. 최신 정보나 외부 자료가 필요할 때 사용한다.",
    schema: z.object({
      query: z.string().describe("검색어"),
      maxResults: z.number().optional().default(5),
    }),
  },
);

const agent = createDeepAgent({ tools: [internetSearch] });

// 기본 프롬프트 앞에 역할·작업 지침을 추가 (가장 흔한 사용)
const agent = createDeepAgent({
  systemPrompt: "너는 전문 리서처다. 철저히 조사한 뒤 출처가 달린 보고서를 /report.md 에 작성한다.",
});

// 기본 프롬프트를 유지하고 뒤에 규칙 추가
const agent2 = createDeepAgent({
  systemPrompt: { suffix: "보고서는 반드시 한국어로 작성한다." },
});

import { createMiddleware, toolCallLimitMiddleware } from "langchain";

let callCount = 0;

const logToolCalls = createMiddleware({
  name: "LogToolCalls",
  wrapToolCall: async (request, handler) => {
    callCount += 1;
    console.log(`[#${callCount}] ${request.toolCall.name}`, JSON.stringify(request.toolCall.args));
    const result = await handler(request);
    console.log(`[#${callCount}] 완료`);
    return result;
  },
});

const agent = createDeepAgent({
  tools: [internetSearch],
  middleware: [logToolCalls, toolCallLimitMiddleware({ toolName: "internet_search", runLimit: 20 })],
});

import { createDeepAgent, type SubAgent } from "deepagents";

const researcher: SubAgent = {
  name: "research-agent",
  description: "심층 조사가 필요한 질문을 맡는다. 질문 하나당 한 번 호출한다.", // 메인 에이전트가 위임 여부를 판단하는 근거
  systemPrompt: "너는 리서처다. 조사 결과를 출처와 함께 500자 이내로 요약해 반환한다.",
  tools: [internetSearch],
  model: "anthropic:claude-haiku-4-5", // 선택. 생략하면 메인 에이전트 모델
};

const agent = createDeepAgent({
  model: "anthropic:claude-sonnet-4-6",
  subagents: [researcher],
});

import { createDeepAgent, StateBackend, StoreBackend, FilesystemBackend, LocalShellBackend, CompositeBackend } from "deepagents";
import { InMemoryStore } from "@langchain/langgraph";

// 기본값 — 스레드 범위 임시 파일시스템
const a1 = createDeepAgent();
const a2 = createDeepAgent({ backend: new StateBackend() }); // 위와 동일

// 로컬 디스크 (rootDir 안으로 격리)
const a3 = createDeepAgent({ backend: new FilesystemBackend({ rootDir: ".", virtualMode: true }) });

// 로컬 디스크 + 셸 실행 (신뢰할 수 있는 로컬 개발 환경에서만)
const a4 = createDeepAgent({ backend: new LocalShellBackend({ rootDir: ".", virtualMode: true }) });

// Store — 스레드를 넘어 유지
const store = new InMemoryStore();
const a5 = createDeepAgent({ store, backend: new StoreBackend({ store }) });

// 경로별 라우팅
const a6 = createDeepAgent({
  store,
  backend: new CompositeBackend(new StateBackend(), { "/memories/": new StoreBackend({ store }) }),
});

import * as z from "zod";

const WeatherReport = z.object({
  location: z.string().describe("보고 대상 지역"),
  temperature: z.number().describe("현재 기온 (섭씨)"),
  condition: z.string().describe("현재 날씨 (맑음, 흐림, 비 등)"),
  forecast: z.string().describe("향후 24시간 요약 예보"),
});

const agent = createDeepAgent({
  tools: [internetSearch],
  responseFormat: WeatherReport,
});

const result = await agent.invoke({ messages: [{ role: "user", content: "서울 날씨 보고서" }] });
console.log(result.structuredResponse); // 스키마 검증을 통과한 객체

import { MultiServerMCPClient } from "@langchain/mcp-adapters";
import { createDeepAgent } from "deepagents";

const client = new MultiServerMCPClient({
  figma: {
    transport: "stdio",
    command: "npx",
    args: ["-y", "figma-developer-mcp", `--figma-api-key=${process.env.FIGMA_API_KEY}`, "--stdio"],
  },
});

const agent = createDeepAgent({
  tools: await client.getTools(),
  systemPrompt: "너는 Figma 디자인을 코드로 옮기는 프론트엔드 개발자다.",
});

import { createDeepAgent } from "deepagents";
import { Command, MemorySaver } from "@langchain/langgraph";
import type { HITLRequest, HITLResponse, Interrupt } from "langchain";

const agent = createDeepAgent({
  tools: [sendEmail],
  checkpointer: new MemorySaver(), // 필수
  interruptOn: {
    write_file: true,                                              // approve / edit / reject 모두 허용
    read_file: false,                                              // 멈추지 않음
    send_email: { allowedDecisions: ["approve", "reject"] },       // 수정 불가
  },
});

const config = { configurable: { thread_id: "hitl-1" } };
let result = await agent.invoke({ messages: [{ role: "user", content: "팀에 주간 보고 메일 보내줘" }] }, config);

while (result.__interrupt__) {
  const request = (result.__interrupt__[0] as Interrupt<HITLRequest>).value;
  console.log(request.actionRequests); // 승인 대기 중인 도구 호출 (이름, 인자)

  const resume: HITLResponse = {
    decisions: request.actionRequests.map(() => ({ type: "approve" as const })),
  };
  result = await agent.invoke(new Command({ resume }), config);
}