Jev

​

Supported Languages

​

What Gets Captured

​

Under a trace root (opt-out tracing)

import { Bitfab } from "@bitfab/sdk"
import { noul, TypeSafeClient } from "@typesafe-ai/sdk"

const bitfab = new Bitfab({ apiKey: process.env.BITFAB_API_KEY })
const jev = new TypeSafeClient()

const screenTicket = bitfab.withTrace("screen-ticket", async (text: string) => {
  const { answers } = await jev.systemOne({
    state: text,
    questions: { billing: noul("Is this about billing?") },
  })
  return answers.billing.noul > 0.5
})

import os
from bitfab import Bitfab
from typesafe_sdk import AsyncTypeSafeClient

bitfab = Bitfab(api_key=os.environ["BITFAB_API_KEY"])
jev = AsyncTypeSafeClient()

@bitfab.trace("screen-ticket")
async def screen_ticket(text: str):
    reply = await jev.system_one(
        state=text,
        questions={"billing": {"type": "noul", "instructions": "Is this about billing?"}},
    )
    return reply.answers["billing"].noul > 0.5

• TypeScript needs the SDK’s build transform in the server build, the same requirement as the rest of opt-out tracing. The transform rewrites x.systemOne(...) calls in your own files, including optional chaining, so it works in bundled apps (Next.js with Turbopack, for example) with nothing extra to import. The call still returns the client’s own result, so @typesafe-ai/sdk’s .withResponse() keeps working. A method taken out first (const ask = jev.systemOne.bind(jev)) is not recognized; wrap it with wrapJev instead.
• Python needs Python 3.12+, as opt-out tracing does. Your own system_one functions are recorded, and the official typesafe_sdk clients are recorded whether they are imported before or after the root starts.
• Ruby needs Ruby 3.4+, as opt-out tracing does. system_one is recorded in your own code and in gems; other methods in those gems stay unrecorded.
• Go needs bitfab-instrument, as opt-out tracing does. It rewrites x.SystemOne(ctx, ...) calls whose method takes a context.Context first and returns (reply, error), including clients from other packages and calls through an interface. A method value taken first (ask := c.SystemOne) is not recognized; wrap it with bitfab.WrapJev instead.
• exclude matches the method name (systemOne / system_one / SystemOne). Excluding it runs the call without recording it. Replay mocking follows the root’s mockOnReplay / mock_on_replay default.
• Usage is recorded once. A wrapper around a recorded call adds nothing, and when one systemOne calls another (your own client calling TypeSafe’s, say), the usage lands on the inner call.
• node() / bitfab_node / Node on the method configures that call’s one span (Python, Ruby, Go): its name, replay mocking, and other options. Its type stays llm unless the node sets one. In TypeScript, withNode does not reach a recognized Jev call: the call’s span keeps its own name and settings.

class JevClient:
    @bitfab.node(name="score-chunk")
    async def system_one(self, **request):
        return await post_to_jev(request)

client.Node((*jevclient.Client).SystemOne, bitfab.NodeOptions{Name: "score-chunk"})

• Outside a trace root, calls run exactly as before and record nothing.

​

Wrapping a Jev call

const askJev = bitfab.wrapJev(jev.systemOne.bind(jev), {
  onReply: (reply) => reportCost(reply.usage),
})

const scoreChunk = bitfab.withSpan("score-chunk", async (excerpt: string) => {
  const { answers } = await askJev({ state: excerpt, questions })
  return answers
})

ask_jev = bitfab.wrap_jev(jev.system_one, on_reply=lambda reply: report_cost(reply.usage))

@bitfab.span("score-chunk")
async def score_chunk(excerpt: str):
    reply = await ask_jev(state=excerpt, questions=questions)
    return reply.answers

ask_jev = bitfab.wrap_jev(on_reply: ->(reply) { report_cost(reply["usage"]) }) do |excerpt|
  post_to_jev(state: excerpt, questions: questions)
end

ask_jev.call(excerpt)

askJev := bitfab.WrapJev(
	func(ctx context.Context, req JevRequest) (JevReply, error) {
		return postToJev(ctx, req)
	},
	bitfab.WithOnReply(func(reply JevReply) { reportCost(reply.Usage) }),
)

reply, err := askJev(ctx, JevRequest{State: excerpt, Questions: questions})

​

Signatures

bitfab.wrapJev(method: (...args) => Reply | Promise<Reply>, options?: WrapJevOptions<Reply>): (...args) => Promise<Reply>
bitfab.getFunction(key).wrapJev(method, options?)

• method must be a named function (bind the client’s method: jev.systemOne.bind(jev)).
• options.onReply?: (reply) => void is called with each reply after it is recorded.

bitfab.wrap_jev(fn, *, on_reply=None)
bitfab.get_function(key).wrap_jev(fn, *, on_reply=None)

• fn may be sync or async and must have a name. The reply may be a dict or an object with model and usage attributes, such as the official client’s SystemOneResponse.

bitfab.wrap_jev(callable = nil, on_reply: nil, &block)
bitfab.get_function(key).wrap_jev(...)

• Pass a callable or a block, not both. The reply may be a Hash with string or symbol keys, or an object that responds to model and usage.

func WrapJev[Req, Reply any](call func(context.Context, Req) (Reply, error), opts ...WrapJevOption[Reply]) func(context.Context, Req) (Reply, error)
func WithOnReply[Reply any](fn func(Reply)) WrapJevOption[Reply]

• The span is the one current in the ctx passed to the call. The reply may be a struct with json tags, a pointer to one, a map[string]any, a json.RawMessage, or a []byte or string holding the JSON body.