APIリファレンス

エージェント

import { Agent } from "@schift-io/sdk";

コンストラクタ

new Agent(options: AgentOptions)

オプション	型	デフォルト	必須
name	string	—	Yes
instructions	string	—	Yes
model	ModelId | string	"gpt-4o-mini"	No
transport	Transport	—	One of transport or baseUrl
baseUrl	string	—	One of transport or baseUrl
apiKey	string	—	No
tools	AgentTool[]	[]	No
rag	RAG	—	No
memory	MemoryConfig	—	No
maxSteps	number	10	No
toolTimeoutMs	number	30000	No
maxToolCalls	number	maxSteps * 5	No
parallelToolExecution	boolean	false	No
skills	SkillsConfig	—	No
extensions	Array<ExtensionInitFn | string>	—	No
mcp	MCPServerConfig[]	—	No

メソッド

メソッド	戻り値	説明
run(input, options?)	Promise<AgentRunResult>	ユーザーメッセージでエージェントを実行します
on(type, handler)	() => void	イベントにサブスクライブします。解除関数を返します
off(type, handler)	void	イベントのサブスクリプションを解除します
toolCount	number	登録されたツールの数（ゲッター）

RAG

import { RAG } from "@schift-io/sdk";

コンストラクタ

new RAG(config: RAGConfig, transport: Transport)

オプション	型	デフォルト
bucket	string	required
topK	number	7

静的プロパティ

プロパティ	型	値
MAX_QUERY_LENGTH	number	8000

メソッド

メソッド	戻り値	説明
search(query: string)	Promise<SearchResultItem[]>	バケットに対するセマンティック検索
chat(query: string)	Promise<ChatResult>	検索 + LLMの回答
asTool(name?: string)	AgentTool	エージェントツールに変換

WebSearch

import { WebSearch } from "@schift-io/sdk";

コンストラクタ

new WebSearch(config?: WebSearchConfig, transport?: Transport)

オプション	型	デフォルト
maxResults	number	5
provider	WebSearchProvider	"schift"
providerApiKey	string	—

メソッド

メソッド	戻り値	説明
search(query: string)	Promise<WebSearchResultItem[]>	ウェブを検索します
asTool(name?: string)	AgentTool	エージェントツールに変換します

---

DeepResearch

import { DeepResearch } from "@schift-io/sdk";

コンストラクタ

new DeepResearch(config?: DeepResearchConfig, llm: LLMFn, transport?: Transport)

オプション	型	デフォルト
maxIterations	number	3
resultsPerSearch	number	5
queriesPerIteration	number	2
queryModel	ModelId | string	"gpt-4o-mini"
synthesisModel	ModelId | string	"gpt-4o-mini"
webSearch	WebSearchConfig	—

メソッド

メソッド	戻り値	説明
run(question: string)	Promise<ResearchReport>	ディープリサーチを実行します
asTool(name?: string)	AgentTool	エージェントツールに変換します

---

ConversationMemory

import { ConversationMemory } from "@schift-io/sdk";

コンストラクタ

new ConversationMemory(config?: MemoryConfig)

オプション	型	デフォルト
maxMessages	number	50
transformContext	(messages: ChatMessage[]) => ChatMessage[]	—

メソッド

メソッド	戻り値	説明
add(message: ChatMessage)	void	メッセージを履歴に追加します
getMessages()	ChatMessage[]	すべてのメッセージを取得します
clear()	void	非システムメッセージをクリアします
length	number	メッセージ数（ゲッター）

ToolRegistry

import { ToolRegistry } from "@schift-io/sdk";

メソッド

メソッド	戻り値	説明
register(tool: AgentTool)	void	ツールを登録します
get(name: string)	AgentTool | undefined	名前でツールを取得します
has(name: string)	boolean	ツールが存在するか確認します
list()	AgentTool[]	すべてのツールをリストします
execute(name, args)	Promise<ToolResult>	名前でツールを実行します
filtered(allowedNames: Set<string>)	ToolRegistry	許可されたツールのみを含む新しいレジストリを作成します
without(blockedNames: Set<string>)	ToolRegistry	ブロックされたツールを除外した新しいレジストリを作成します
toOpenAI()	Array	OpenAI互換のツール定義を生成します
toAnthropic()	Array	Anthropic互換のツール定義を生成します

AgentEventEmitter

import { AgentEventEmitter } from "@schift-io/sdk";

メソッド

メソッド	戻り値	説明
on(type, handler)	() => void	イベントに登録します。解除関数を返します
on("*", handler)	() => void	すべてのイベントに登録します
off(type, handler)	void	イベントから解除します
emit(event)	void	イベントを発火します
removeAll()	void	すべてのハンドラを削除します

SkillLoader

import { SkillLoader, loadSkills } from "@schift-io/sdk";

コンストラクタ

new SkillLoader(skillsDir: string)

メソッド

メソッド	戻り値	説明
loadAll(options?)	Promise<SkillSummary[]>	すべてのスキルファイルを読み込みます
get(name: string)	Promise<Skill | undefined>	名前でスキルを取得します
getAll()	Promise<Skill[]>	読み込まれたすべてのスキルを取得します
reload(name: string)	Promise<Skill | undefined>	特定のスキルを再読み込みします

便利な使い方

const loader = await loadSkills("./skills");
// Equivalent to: new SkillLoader("./skills") + loadAll()

SkillResolver

import { SkillResolver } from "@schift-io/sdk";

コンストラクタ

new SkillResolver(loader: SkillLoader)

メソッド

メソッド	戻り値	説明
resolve(query)	Promise<Skill[]>	すべてのスキルを取得します
resolvePrimary(query)	Promise<ResolvedSkill | undefined>	クエリに対する最適なスキルを取得します
buildPromptSection(skills)	{ promptText, allowedTools }	プロンプトインジェクションセクションを構築します

---

ポリシーエンジン

import { PolicyEngine, policyViolation } from "@schift-io/sdk";

コンストラクタ

new PolicyEngine(contract: SkillContract)

メソッド

メソッド	戻り値	説明
beforeTool(input)	PolicyDecision	ツール呼び出しが許可されているか確認します
afterTool(input)	PolicyDecision	ツールの結果を検証します

ヘルパー

policyViolation(reason: string): ToolResult
// Returns { success: false, data: null, error: "POLICY_VIOLATION:reason" }

拡張ホスト

import { ExtensionHost } from "@schift-io/sdk";

メソッド

メソッド	戻り値	説明
load(extension)	Promise<void>	拡張機能（関数またはモジュールパス）を読み込みます。

管理されたエージェント

サーバーサイドの管理されたエージェント — Schift Cloud APIを介してエージェントを作成、構成、実行します。

AgentsClient

const client = schift.agents;

メソッド	戻り値	説明
create(req: CreateAgentRequest)	Promise<AgentResponse>	管理されたエージェントを作成します
list()	Promise<AgentResponse[]>	すべてのエージェントを一覧表示します
get(id: string)	Promise<AgentResponse>	IDでエージェントを取得します
update(id, req)	Promise<AgentResponse>	エージェントを更新します
delete(id: string)	Promise<void>	エージェントを削除します
runs(agentId: string)	RunsClient	エージェントのためのランクライアントを取得します

RunsClient

const runs = schift.agents.runs("agt_abc123");

メソッド	戻り値	説明
create(req: CreateRunRequest)	Promise<RunResponse>	ランを開始します
list()	Promise<RunResponse[]>	すべてのランを一覧表示します
get(runId: string)	Promise<RunResponse>	IDでランを取得します
streamEvents(runId, afterSeq?)	AsyncGenerator<RunEvent>	ランイベントをストリームします

---

WorkspaceClient (クライアント)

import { WorkspaceClient } from "@schift-io/sdk";

コンストラクタ

new WorkspaceClient(config: SchiftConfig)

オプション	型	デフォルト
apiKey	string	必須 (sch_で始まる必要があります)
baseUrl	string	ホストされたAPIオリジン
timeout	number	60000

プロパティ

プロパティ	型	説明
transport	HttpTransport	エージェント/RAG用のHTTPトランスポート
workflows	WorkflowClient	ワークフローサブクライアント
agents	AgentsClient	管理されたエージェントのサブクライアント
models	ModelsClient	モデルカタログ
db	DBClient	バケット/ドキュメント管理
tools	SchiftTools	ツール定義ヘルパー

コアメソッド

メソッド	戻り値	説明
embed(request)	Promise<EmbedResponse>	エンベディングを生成
embedBatch(request)	Promise<EmbedBatchResponse>	バッチエンベディング
search(request)	Promise<SearchResult[]>	ベクトル検索
chat(request)	Promise<ChatResponse>	RAGチャット
chatStream(request)	AsyncGenerator<ChatStreamEvent>	SSEストリーミング付きRAGチャット
webSearch(query, maxResults?)	Promise<WebSearchResultItem[]>	ウェブ検索
aggregate(request)	Promise<AggregateResponse>	メタデータ集計
rerank(request)	Promise<RerankResult>	ドキュメントを再ランク付け
similarity(request)	Promise<{ score: number }>	テキスト類似度スコア
cluster(request)	Promise<ClusterResult>	テキストクラスタリング
classify(request)	Promise<ClassifyResult>	ゼロショット分類

バケットメソッド

メソッド	戻り値	説明
listBuckets()	Promise<Bucket[]>	すべてのバケットを一覧表示
createBucket(request)	Promise<Bucket>	バケットを作成
deleteBucket(nameOrId)	Promise<void>	バケットを削除
bucketSearch(nameOrId, request)	Promise<SearchResult>	バケットを検索
bucketGraph(nameOrId, query?, topK?)	Promise<GraphResult>	バケットのグラフクエリ
db.upload(bucket, options)	Promise<BucketUploadResult>	バケットにファイルをアップロード

エッジメソッド

メソッド	戻り値	説明
addEdges(nameOrId, edges)	Promise<{ count: number }>	グラフエッジを追加
listEdges(nameOrId, nodeId, options?)	Promise<EdgeListResult>	ノードのエッジを一覧表示
deleteEdge(nameOrId, source, target, relation?)	Promise<void>	エッジを削除

コレクションメソッド

メソッド	戻り値	説明
listCollections()	Promise<Collection[]>	コレクションを一覧表示
getCollection(id)	Promise<Collection>	IDでコレクションを取得
createCollection(request)	Promise<Collection>	コレクションを作成
deleteCollection(id)	Promise<void>	コレクションを削除
collectionStats(id)	Promise<Stats>	コレクション統計を取得
collectionAdd(collection, request)	Promise<Result>	コレクションにドキュメントを追加
collectionSearch(collection, request)	Promise<SearchResult>	コレクションを検索
upsertVectors(collection, vectors)	Promise<Result>	生のベクトルをアップサート
deleteVectors(collection, ids)	Promise<Result>	IDでベクトルを削除
upsertDocuments(collection, documents, model)	Promise<Result>	エンベディング付きでドキュメントをアップサート

LLM ルーティング

メソッド	戻り値	説明
chatCompletion(request)	Promise<ChatCompletionResult>	OpenAI互換チャット完了
listModels()	Promise<Model[]>	利用可能なLLMモデルを一覧表示
getRouting()	Promise<RoutingConfig>	現在のルーティング設定を取得
setRouting(request)	Promise<RoutingConfig>	ルーティング設定を設定

使用状況とジョブ

メソッド	戻り値	説明
usage()	Promise<Usage>	現在の使用状況を取得
usageSummary()	Promise<UsageSummary>	使用状況の要約を取得
getJob(jobId)	Promise<Job>	ジョブステータスを取得
listJobs(options?)	Promise<Job[]>	ジョブを一覧表示
cancelJob(jobId)	Promise<Job>	ジョブをキャンセル
reprocessJob(jobId)	Promise<Job>	失敗したジョブを再処理

SchiftTools

プロバイダー固有のツール定義を生成するツール呼び出しヘルパーです。schift.toolsで自動的に作成されます。

// OpenAI format
const tools = schift.tools.openai();
// Anthropic format
const tools = schift.tools.anthropic();
// Vercel AI SDK format
const tools = schift.tools.vercelAI();
// Handle any tool call (auto-detects format)
const result = await schift.tools.handle(toolCall);

メソッド	戻り値	説明
openai()	object[]	OpenAI互換のツール定義
anthropic()	object[]	Anthropic互換のツール定義
vercelAI()	Record<string, object>	Vercel AI SDKツール定義
handle(toolCall)	Promise<string>	任意のプロバイダーからツール呼び出しを実行

タイプ

AgentTool

interface AgentTool {
  name: string;                // Must match /^[a-zA-Z_][a-zA-Z0-9_]*$/
  description: string;
  parameters?: JSONSchema;
  handler: (args: Record<string, unknown>) => Promise<ToolResult>;
  maxCallsPerRun?: number;    // 実行ごとの呼び出し制限
}

ToolResult

interface ToolResult {
  success: boolean;
  data: unknown;
  error?: string;
}

AgentRunResult

interface AgentRunResult {
  steps: AgentStep[];
  output: string;
  totalDurationMs: number;
}

AgentStep

interface AgentStep {
  id: string;
  type: "think" | "tool_call" | "tool_result" | "final_answer" | "error";
  content?: string;
  toolName?: string;
  toolArgs?: Record<string, unknown>;
  toolResult?: ToolResult;
  durationMs: number;
}

RunOptions

interface RunOptions {
  requestId?: string;
  signal?: AbortSignal;
}

ChatMessage

interface ChatMessage {
  role: "system" | "user" | "assistant" | "tool";
  content: string;
  toolCallId?: string;
  toolName?: string;
}

SkillsConfig

interface SkillsConfig {
  loader: SkillLoader;
  autoResolve?: boolean;  // デフォルト: true
}

SkillContract

interface SkillContract {
  skillName: string;
  model?: string;
  allowedTools?: string[];
  blockedTools?: string[];
  procedures?: string[];
  constraints?: string[];
}

SkillFrontmatter

interface SkillFrontmatter {
  name: string;
  description: string;
  model?: string;
  "allowed-tools"?: string[];
  "blocked-tools"?: string[];
  procedures?: string[];
  constraints?: string[];
  rag?: string;
}

PolicyDecision

interface PolicyDecision {
  allowed: boolean;
  stage: "before_tool" | "after_tool" | "procedure" | "constraint";
  reason?: string;
}

ExtensionAPI

interface ExtensionAPI {
  registerTool(tool: AgentTool): void;
  on<K extends AgentEventType>(type: K, handler: (event: AgentEventMap[K]) => void): () => void;
  off<K extends AgentEventType>(type: K, handler: (event: AgentEventMap[K]) => void): void;
  readonly agentName: string;
}

MCPServerConfig

interface MCPServerConfig {
  transport: "stdio" | "sse";
  command?: string;
  args?: string[];
  url?: string;
  toolPrefix?: string;
}

管理されたエージェントタイプ

interface CreateAgentRequest {
  name: string;
  model?: string;
  instructions?: string;
  tools?: AgentToolDef[];
  ragConfig?: RagConfig;
  metadata?: Record<string, unknown>;
}

interface AgentResponse {
  id: string;
  orgId: string;
  name: string;
  model: string;
  instructions: string;
  tools: AgentToolDef[];
  ragConfig: RagConfig;
  metadata: Record<string, unknown>;
  createdAt: string;
  updatedAt: string;
}

interface RunResponse {
  id: string;
  agentId: string;
  orgId: string;
  status: "pending" | "running" | "success" | "error" | "timeout";
  inputText: string;
  outputText?: string;
  error?: string;
  tokensUsed: number;
  durationMs?: number;
  createdAt: string;
  finishedAt?: string;
}

interface RunEvent {
  seq: number;
  eventType: string;
  [key: string]: unknown;
}

イベントタイプ

type AgentEventType =
  | "agent_start"
  | "turn_start"
  | "tool_call"
  | "tool_result"
  | "message_delta"
  | "agent_end"
  | "error"
  | "policy_violation";

各イベントには type、runId、および timestamp が含まれます。追加フィールドはイベントタイプによって異なります：

イベント	追加フィールド
agent_start	input
turn_start	turnIndex
tool_call	toolName, toolArgs, callId
tool_result	toolName, callId, result, durationMs
message_delta	content
agent_end	output, totalDurationMs
error	error
policy_violation	skillName, stage, reason, toolName?

WebSearchProvider

const WebSearchProvider = {
  SCHIFT: "schift",
  TAVILY: "tavily",
  SERPER: "serper",
  BRAVE: "brave",
} as const;

モデルカタログ

import { OpenAIModel, GeminiModel, ClaudeModel } from "@schift-io/sdk";

// OpenAI
OpenAIModel.GPT_5_5_PRO      // "gpt-5.5-pro"
OpenAIModel.GPT_5_5          // "gpt-5.5"
OpenAIModel.GPT_5_4          // "gpt-5.4"
OpenAIModel.GPT_5_4_MINI     // "gpt-5.4-mini"
OpenAIModel.GPT_5_4_NANO     // "gpt-5.4-nano"
OpenAIModel.GPT_4_1          // "gpt-4.1"
OpenAIModel.GPT_4_1_MINI     // "gpt-4.1-mini"
OpenAIModel.GPT_4_1_NANO     // "gpt-4.1-nano"
OpenAIModel.GPT_4O           // "gpt-4o"
OpenAIModel.GPT_4O_MINI      // "gpt-4o-mini"
OpenAIModel.O3               // "o3"
OpenAIModel.O3_MINI          // "o3-mini"
OpenAIModel.O3_PRO           // "o3-pro"
OpenAIModel.O4_MINI          // "o4-mini"

// Google
GeminiModel.GEMINI_3_1_PRO       // "gemini-3.1-pro"
GeminiModel.GEMINI_3_1_FLASH     // "gemini-3.1-flash"
GeminiModel.GEMINI_3_1_FLASH_LITE // "gemini-3.1-flash-lite"
GeminiModel.GEMINI_2_5_PRO       // "gemini-2.5-pro"
GeminiModel.GEMINI_2_5_FLASH     // "gemini-2.5-flash"
GeminiModel.GEMINI_2_5_FLASH_LITE // "gemini-2.5-flash-lite"

// Anthropic
ClaudeModel.OPUS_4_8         // "claude-opus-4-8"
ClaudeModel.OPUS_4_6         // "claude-opus-4-6"
ClaudeModel.SONNET_4_6       // "claude-sonnet-4-6"
ClaudeModel.HAIKU_4_5        // "claude-haiku-4-5-20251001"

エラークラス

import {
  SchiftError,       // 基本エラー (status, code)
  AuthError,         // 401 - 無効なAPIキー
  QuotaError,        // 402 - クォータ超過
  EntitlementError,  // 403 - アップグレードが必要
  AgentError,        // エージェントの失敗 (stepId)
  ToolError,         // ツール実行の失敗 (toolName)
  MaxStepsError,     // 最大ReAct反復回数に達しました
} from "@schift-io/sdk";