Replay Mocking

const articlePipeline = bitfab.getFunction("process-article")

const fetchArticle = articlePipeline.withSpan(
  { name: "fetch-article-from-db", mockOnReplay: true },
  async (id: string) => db.articles.findById(id),
)

const summarize = articlePipeline.withSpan(
  { name: "summarize-article" },
  async (article: Article) => summarizeWithNewPrompt(article),
)

const processArticle = articlePipeline.withSpan(
  { name: "process-article" },
  async (id: string) => summarize(await fetchArticle(id)),
)

article_pipeline = bitfab.get_function("process-article")


@article_pipeline.span(name="fetch-article-from-db", mock_on_replay=True)
def fetch_article_from_db(article_id: str) -> Article:
    return db.articles.find_by_id(article_id)


@article_pipeline.span(name="summarize-article")
def summarize_article(article: Article) -> Summary:
    return summarize_with_new_prompt(article)


@article_pipeline.span(name="process-article")
def process_article(article_id: str) -> Summary:
    return summarize_article(fetch_article_from_db(article_id))

class ArticleProcessor
  include Bitfab::Traceable
  bitfab_function "process-article"

  bitfab_span :fetch_article_from_db, name: "fetch-article-from-db", mock_on_replay: true
  def fetch_article_from_db(article_id)
    db.articles.find_by_id(article_id)
  end

  bitfab_span :summarize_article, name: "summarize-article"
  def summarize_article(article)
    summarize_with_new_prompt(article)
  end

  bitfab_span :process_article, name: "process-article"
  def process_article(article_id)
    summarize_article(fetch_article_from_db(article_id))
  end
end

func fetchArticleFromDB(ctx context.Context, articleID string) (Article, error) {
    value, err := client.Span(
        ctx,
        "process-article",
        func(ctx context.Context) (any, error) {
            return db.Articles.FindByID(ctx, articleID)
        },
        bitfab.WithName("fetch-article-from-db"),
        bitfab.WithInput(articleID),
        bitfab.WithMockOnReplay(true),
        bitfab.WithMockOutputType[Article](),
    )
    if err != nil {
        return Article{}, err
    }
    return value.(Article), nil
}

const result = await bitfab.replay("process-article", processArticle, {
  limit: 10,
})

console.log(result.experimentUrl)

result = bitfab.replay(process_article, limit=10)
print(result["experiment_url"])

processor = ArticleProcessor.new
result = Bitfab.client.replay(
  processor, :process_article,
  trace_function_key: "process-article",
  limit: 10,
)

puts result[:experiment_url]

result, err := client.Replay(
    context.Background(),
    "process-article",
    processArticle,
    &bitfab.ReplayOptions{Limit: 10},
)

const result = await bitfab.replay("process-article", processArticle, {
  mock: "none", // run everything real...
  mockOverride: {
    // ...except this one call, which gets a value you supply
    match: (node) => node.spanName === "fetch-article-from-db",
    value: { id: "fixed", title: "Fixed title" }, // a flat value
  },
})

from bitfab import MockOverride

result = bitfab.replay(
    process_article,
    mock="none",  # run everything real...
    mock_override=MockOverride(
        # ...except this one call, which gets a value you supply
        match=lambda node: node.span_name == "fetch-article-from-db",
        value={"id": "fixed", "title": "Fixed title"},  # a flat value
    ),
)

result = Bitfab.client.replay(
  processor, :process_article,
  trace_function_key: "process-article",
  mock: "none", # run everything real...
  mock_override: {
    # ...except this one call, which gets a value you supply
    match: ->(node) { node[:span_name] == "fetch-article-from-db" },
    value: { id: "fixed", title: "Fixed title" } # a flat value
  }
)

result, err := client.Replay(ctx, "process-article", processArticle, &bitfab.ReplayOptions{
    Mock: bitfab.MockNone,
    MockOverrides: []bitfab.MockOverride{{
        Match: func(node bitfab.SpanNodeMeta) bool {
            return node.SpanName == "fetch-article-from-db"
        },
        Value: Article{ID: "fixed", Title: "Fixed title"},
    }},
})

// getOriginalOutput() is async in the TypeScript SDK
value: async ({ getOriginalOutput }) => {
  const original = await getOriginalOutput()
  return { ...original, score: 1 } // override one field, keep the rest
}

# get_original_output() is synchronous in the Python SDK
value=lambda ctx: {**ctx.get_original_output(), "score": 1}

# get_original_output is synchronous in the Ruby SDK
value: ->(ctx) { ctx[:get_original_output].call.merge(score: 1) }

Resolve: func(ctx bitfab.MockOverrideContext) (any, error) {
    original, err := ctx.GetOriginalOutput()
    if err != nil {
        return nil, err
    }
    value := original.(Result)
    value.Score = 1
    return value, nil
}

bitfab.registerMockOverride({
  match: (node) => node.type === "llm",
  value: { label: "refund" },
})
// Ordered form (equivalent): registerMockOverride(match, value)
bitfab.clearMockOverrides() // reset

bitfab.register_mock_override(
    MockOverride(match=lambda node: node.type == "llm", value={"label": "refund"})
)
# Ordered form (equivalent): register_mock_override(match, value)
bitfab.clear_mock_overrides()  # reset

Bitfab.client.register_mock_override(
  match: ->(node) { node[:type] == "llm" },
  value: { label: "refund" }
)
# Positional form (equivalent): register_mock_override(match, value)
Bitfab.client.clear_mock_overrides # reset

err := client.RegisterMockOverride(bitfab.MockOverride{
    Match: func(node bitfab.SpanNodeMeta) bool { return node.Type == "llm" },
    Value: map[string]any{"label": "refund"},
})
client.ClearMockOverrides()

import { NO_MOCK_OVERRIDE } from "@bitfab/sdk"

bitfab.registerMockOverride("checkout-agent", ({ node }) =>
  node.spanName === "Classifier"
    ? { label: "refund" }
    : NO_MOCK_OVERRIDE,
)

from bitfab import NO_MOCK_OVERRIDE

client.register_mock_override(
    "checkout-agent",
    lambda ctx: (
        {"label": "refund"}
        if ctx.node.span_name == "Classifier"
        else NO_MOCK_OVERRIDE
    )
)

client.register_mock_override("checkout-agent", lambda do |ctx|
  if ctx[:node][:span_name] == "Classifier"
    {label: "refund"}
  else
    Bitfab::NO_MOCK_OVERRIDE
  end
end)

optionsFactory: ({ params }) => ({
  mockOverride: createIntentMock(params.forcedLabel),
})

options_factory=lambda ctx: {
    "mock_override": create_intent_mock(ctx.params.get("forcedLabel"))
}

options_factory: ->(ctx) {
  {mock_override: IntentMocks.build(ctx.params["forcedLabel"])}
}