SDK and Agent alpha quickstart

npm init -y
npm install @spfunctions/sdk@0.1.0-alpha.0 @spfunctions/agent@0.1.0-alpha.0

export SF_API_KEY="sf_..."

export OPENROUTER_API_KEY="..."

import { SimpleFunctions } from "@spfunctions/sdk"

const sf = new SimpleFunctions({
  baseUrl: "https://simplefunctions.dev",
})

const manifest = await sf.manifest.list()
const world = await sf.manifest.get("world.read")
const legacy = await sf.manifest.get("get_world_state")

console.log(manifest.schemaVersion)
console.log(world?.name)
console.log(legacy)

0.3.0-draft
world.read
null

import { SimpleFunctions } from "@spfunctions/sdk"

const sf = new SimpleFunctions({
  baseUrl: "https://simplefunctions.dev",
  apiKey: process.env.SF_API_KEY,
})

const world = await sf.world.get()

console.log(world.asOf)
console.log(world.regime?.label)
console.log(world.salient?.slice(0, 3).map(item => item.label))

const search = await sf.markets.search({
  query: "Fed CPI",
  venue: "kalshi",
  limit: 5,
})

for (const market of search.markets ?? []) {
  console.log(market.ticker, market.title, market.price)
}

const firstTicker = search.markets?.[0]?.ticker
if (firstTicker) {
  const detail = await sf.markets.get(firstTicker)
  const history = await sf.markets.history(firstTicker)
  console.log(detail.title)
  console.log(history)
}

import {
  MissingApiKeyError,
  PermissionDeniedError,
  SimpleFunctionsRateLimitError,
} from "@spfunctions/sdk"

try {
  await sf.theses.list()
} catch (error) {
  if (error instanceof MissingApiKeyError) {
    console.error("missing key", error.tool, error.reason)
  } else if (error instanceof PermissionDeniedError) {
    console.error("permission denied", error.requestId)
  } else if (error instanceof SimpleFunctionsRateLimitError) {
    console.error("rate limited")
  } else {
    throw error
  }
}

import { SimpleFunctions } from "@spfunctions/sdk"
import { SimpleFunctionsAgent } from "@spfunctions/agent"

const sf = new SimpleFunctions({
  baseUrl: "https://simplefunctions.dev",
  apiKey: process.env.SF_API_KEY,
})

const agent = new SimpleFunctionsAgent({
  client: sf,
  policy: {
    maxSideEffect: "none",
    maxCostEffect: "api_cost",
  },
})

const result = await agent.call("world.read", {})
console.log(result.tool)
console.log(result.output)

const result = await agent.tools.world.read({})

for await (const event of agent.stream("world.read", {})) {
  console.log(event.type, event.runId, event.callId)
}

import type { AgentToolInput, AgentToolName } from "@spfunctions/agent"

const name: AgentToolName = "markets.search"

const input: AgentToolInput<"markets.search"> = {
  query: "oil geopolitics",
  limit: 5,
}

const searchAgent = new SimpleFunctionsAgent({
  client: sf,
  policy: {
    maxSideEffect: "none",
    maxCostEffect: "search_cost",
  },
})

await searchAgent.call(name, input)

import { FileTraceStore, ReplayMissError } from "@spfunctions/agent"

const trace = new FileTraceStore("./sf-agent.trace.jsonl")

await agent.tools.world.read({}, { trace })

const replay = new SimpleFunctionsAgent({
  client: new SimpleFunctions({ baseUrl: "https://simplefunctions.dev" }),
  mode: "replayOnly",
  trace: new FileTraceStore("./sf-agent.trace.jsonl"),
})

const replayed = await replay.tools.world.read({})
console.log(replayed.replayed)

try {
  await replay.tools.world.delta({ since: "1h" })
} catch (error) {
  if (error instanceof ReplayMissError) {
    console.log("Replay miss. No live call was made.")
  }
}

import { OpenRouterProvider, query } from "@spfunctions/agent/v1"

const provider = new OpenRouterProvider({
  apiKey: process.env.OPENROUTER_API_KEY,
})

for await (const message of query({
  prompt: "Summarize what prediction markets imply about Fed cuts.",
  options: {
    provider,
    model: "anthropic/claude-haiku-4.5",
    maxTurns: 3,
    maxBudgetUsd: 0.25,
  },
})) {
  console.log(message.type)
}

import { createSimpleFunctionsBuiltinTools, query } from "@spfunctions/agent/v1"

const tools = createSimpleFunctionsBuiltinTools(sf)

for await (const message of query({
  prompt: "Find markets related to inflation and explain the top signal.",
  options: {
    provider,
    tools,
    allowedTools: ["markets.search", "market.inspect", "world.read"],
    maxTurns: 4,
    maxBudgetUsd: 0.50,
  },
})) {
  console.log(message.type)
}

import { watch } from "@spfunctions/agent/v1"

for await (const tick of watch.ticks({
  tickers: ["KXEXAMPLE"],
  cadence: "5min",
  cycles: 1,
})) {
  console.log(tick.ticker, tick.price, tick.delta)
}

for await (const message of query({
  prompt: "React to these ticks and inspect anything surprising.",
  options: {
    provider,
    watch: [
      { kind: "ticks", tickers: ["KXEXAMPLE"], cadence: "5min" },
    ],
    tools: createSimpleFunctionsBuiltinTools(sf),
    allowedTools: ["market.inspect", "world.read"],
    maxTurns: 4,
  },
})) {
  console.log(message.type)
}