id stringlengths 18 18 | chunk_id stringlengths 16 16 | repo stringclasses 6
values | repo_url stringclasses 6
values | commit stringclasses 6
values | license stringclasses 4
values | path stringlengths 10 68 | kind stringclasses 1
value | name stringlengths 5 44 | context stringlengths 10 68 | start_line int32 1 1 | end_line int32 3 1.42k | num_lines int32 3 1.42k | question stringlengths 133 1.46k | answer stringlengths 44 54.5k | model stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
7d4304d1c2adad9e-0 | 7d4304d1c2adad9e | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-core/src/realtime/mod.rs | file | mod.rs | flowcat-core/src/realtime/mod.rs | 1 | 272 | 272 | Generate a Rust module for a speech-to-speech realtime model abstraction. Define a `RealtimeLlm` trait with async methods `connect(RealtimeSetup)`, `send_audio(AudioChunk)`, `update_system(String, Vec<ToolDecl>)`, `send_tool_result(String, serde_json::Value)`, `next_event()` -> `Option<RealtimeEvent>`, and a `poll_even... | // SPDX-License-Identifier: Apache-2.0
//
//! The speech-to-speech model abstraction. `GeminiLive` is the first impl.
//!
//! See DESIGN.md "Trait contracts" + "Gemini Live protocol". Audio in is 16 kHz
//! PCM; audio out (in [`RealtimeEvent::AudioOut`]) is 24 kHz PCM for Gemini Live.
pub mod gemini_live;
pub mod serv... | nvidia/nemotron-3.5-lightning-30b-a3b |
9f468e6a82829a97-0 | 9f468e6a82829a97 | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-core/src/service/adapters.rs | file | adapters.rs | flowcat-core/src/service/adapters.rs | 1 | 620 | 620 | Write Rust adapter structs `SttProcessor`, `LlmProcessor`, and `TtsProcessor` that implement `FrameProcessor` for `SttService`, `LlmService`, and `TtsService`, handling audio input, metrics flushing, mute control, and barge-in cancellation. | // SPDX-License-Identifier: Apache-2.0
//
//! Service-processor adapters — the public [`FrameProcessor`] wrappers that lift a
//! frozen [`SttService`]/[`LlmService`]/[`TtsService`] (in [`crate::service`]) into
//! a pipeline node.
//!
//! These were the tiny adapters previously living in `service/mod.rs`'s
//! `#[cfg(... | nvidia/nemotron-3.5-lightning-30b-a3b |
2565f4ee1f94e0f7-0 | 2565f4ee1f94e0f7 | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-core/src/session.rs | file | session.rs | flowcat-core/src/session.rs | 1 | 221 | 221 | Write a Rust module that defines a SessionSource trait for bootstrapping and finalizing calls in a voice AI pipeline. The trait must include async methods resolve, complete, artifact_upload_url, put_bytes, node_tools, and tool_call, using FlowcatError for error handling and types ResolvedCall, Finalize, UploadTarget, U... | // SPDX-License-Identifier: Apache-2.0
//
//! Call bootstrap + finalize seam.
//!
//! The embedder implements [`SessionSource`] over its own control-plane HTTP
//! API (resolve a run+token into a call config, upload artifacts, write the
//! finalize). flowcat-core only sees the opaque shapes (see DESIGN.md
//! "Trait c... | nvidia/nemotron-3.5-lightning-30b-a3b |
d84cfb7e44fef7c1-0 | d84cfb7e44fef7c1 | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-core/src/transport/media.rs | file | media.rs | flowcat-core/src/transport/media.rs | 1 | 66 | 66 | Write a Rust trait called MediaTransport that serves as a transport-agnostic media seam for a SIP VoIP pipeline. It should handle inbound/outbound decoded audio and lifecycle events across different carriers. The inbound type should be an enum with three variants: one for when the media stream starts carrying a carrier... | // SPDX-License-Identifier: Apache-2.0
//
//! The `MediaTransport` trait — Flowcat's transport-agnostic *media* seam.
//!
//! Where [`MediaSocket`](crate::transport::MediaSocket) is a raw WS frame pipe,
//! `MediaTransport` is one level up: it speaks **decoded audio + lifecycle
//! events**, so the [S2S pipeline](crate... | nvidia/nemotron-3.5-lightning-30b-a3b |
21d1b38dcb338bf0-0 | 21d1b38dcb338bf0 | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-core/src/serializer/mod.rs | file | mod.rs | flowcat-core/src/serializer/mod.rs | 1 | 32 | 32 | I need a Rust module defining a pure, carrier-specific WebSocket framing trait that normalizes inbound WS frames into SerIn events and encodes outbound audio chunks and clear control frames into WsOut. The trait must be Send, have no I/O or async, and include methods on_message(&mut self, msg: &WsIn) -> SerIn, encode_a... | // SPDX-License-Identifier: Apache-2.0
//
//! Per-carrier WebSocket framing. **Pure** (no I/O): turns inbound frames into
//! normalized [`SerIn`] events and encodes outbound audio/clears into [`WsOut`].
//!
//! See DESIGN.md "Trait contracts". The one concrete serializer is `plivo`
//! (Plivo `<Stream>` JSON+base64). ... | nvidia/nemotron-3.5-lightning-30b-a3b |
23e0f8c495116637-0 | 23e0f8c495116637 | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-core/src/transport/socket.rs | file | socket.rs | flowcat-core/src/transport/socket.rs | 1 | 28 | 28 | I need a Rust trait called `MediaSocket` that models a bidirectional WebSocket media socket for a transport-agnostic pipeline. It must have three async methods: `recv` yielding `Option<WsIn>` for inbound frames, `send_text(String) -> Result<(), FlowcatError>` for text, and `send_binary(Vec<u8>) -> Result<(), FlowcatErr... | // SPDX-License-Identifier: Apache-2.0
//
//! The `MediaSocket` trait — Flowcat's transport-agnostic media seam.
//!
//! Flowcat does not own the socket; the host adapts whatever it has (an axum WS,
//! a tungstenite client, a mock) to this trait. See DESIGN.md "Trait contracts".
use async_trait::async_trait;
use cra... | nvidia/nemotron-3.5-lightning-30b-a3b |
a1cc153058636dce-0 | a1cc153058636dce | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-core/src/transport/mod.rs | file | mod.rs | flowcat-core/src/transport/mod.rs | 1 | 20 | 20 | I need a Rust module for a transport layer that exposes two primary abstractions: a raw WebSocket text/binary frame pipe and a transport-agnostic decoded-audio seam for an audio pipeline. The module should publicly re-export the types `MediaSocket`, `MediaIn`, `MediaTransport`, `WsMediaTransport`, and `WsCarrierTranspo... | // SPDX-License-Identifier: Apache-2.0
//
//! Transport layer.
//!
//! Two seams live here:
//! - [`MediaSocket`] — a raw bidirectional WS text/binary frame pipe, with a
//! tungstenite-backed [`WsMediaTransport`] implementation.
//! - [`MediaTransport`] — the transport-agnostic *decoded-audio* seam the
//! pipelin... | nvidia/nemotron-3.5-lightning-30b-a3b |
25aeb0266722e84d-0 | 25aeb0266722e84d | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-core/src/transport/carrier.rs | file | carrier.rs | flowcat-core/src/transport/carrier.rs | 1 | 248 | 248 | I need a Rust implementation of a `WsCarrierTransport` struct that adapts a raw WebSocket socket and a per-carrier `MediaSerializer` into a decoded-audio `MediaTransport` for a speech pipeline. The struct should be generic over `So: MediaSocket` and `Se: MediaSerializer`, composed via `new(socket, serializer)`. It must... | // SPDX-License-Identifier: Apache-2.0
//
//! `WsCarrierTransport` — adapts the WS path to the [`MediaTransport`] seam.
//!
//! It composes the two lower WS seams — a [`MediaSocket`] (raw text/binary
//! frames) and a [`MediaSerializer`] (pure per-carrier framing) — into the
//! decoded-audio [`MediaTransport`] the pip... | nvidia/nemotron-3.5-lightning-30b-a3b |
388d76249fc6f28e-0 | 388d76249fc6f28e | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-core/src/transport/ws_media.rs | file | ws_media.rs | flowcat-core/src/transport/ws_media.rs | 1 | 211 | 211 | I need a Rust module defining a generic `WsMediaTransport<S>` that implements `MediaSocket` over a tungstenite Message stream/sink. It should provide an async `connect(url)` method that uses `tokio_tungstenite::connect_async` to establish a client WebSocket connection and wrap it, and a `new(socket)` constructor for se... | // SPDX-License-Identifier: Apache-2.0
//
//! `WsMediaTransport` — a [`MediaSocket`] over a `tokio-tungstenite` WebSocket.
//!
//! Flowcat does not own the socket: it is **generic over any tungstenite-message
//! stream/sink** so a host can plug in whatever it has. The standalone client
//! path ([`WsMediaTransport::co... | nvidia/nemotron-3.5-lightning-30b-a3b |
5c9f16a65d7636d9-0 | 5c9f16a65d7636d9 | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-server/src/main.rs | file | main.rs | flowcat-server/src/main.rs | 1 | 94 | 94 | I need a Rust binary entry point that loads an agent config, resolves a dependency graph, and starts an Axum HTTP server. The code must install a rustls crypto provider, initialize tracing with environment-based filtering, and determine the config path from --config or -c arguments, a positional argument, or the $FLOWC... | // SPDX-License-Identifier: Apache-2.0
//
//! `flowcat-server` binary: load an agent config and serve it over HTTP.
//!
//! ```text
//! flowcat-server --config agent.yaml # or a positional path, or $FLOWCAT_CONFIG
//! ```
//!
//! Resolves the agent graph from the config, then runs an axum server exposing
//! `/hea... | nvidia/nemotron-3.5-lightning-30b-a3b |
81e2229f683a12b1-0 | 81e2229f683a12b1 | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-core/src/sip/mod.rs | file | mod.rs | flowcat-core/src/sip/mod.rs | 1 | 30 | 30 | I'm implementing a SIP module for a Rust real-time communication library. The module must act as a SIP user agent on a trunk, handling REGISTER requests with digest authentication and periodic refresh, accepting inbound INVITEs, and originating outbound INVITEs. Audio is carried over hand-rolled RTP over a tokio UDP so... | // SPDX-License-Identifier: Apache-2.0
//
//! Native SIP/RTP: Flowcat speaks SIP directly (no FreeSWITCH).
//!
//! This module makes a `flowcat-core` process a SIP user agent on a trunk:
//! REGISTER (with digest auth + periodic refresh), accept inbound INVITEs, and
//! originate outbound INVITEs — then carry the call'... | nvidia/nemotron-3.5-lightning-30b-a3b |
30c7fc2d7049d55a-0 | 30c7fc2d7049d55a | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-server/src/session.rs | file | session.rs | flowcat-server/src/session.rs | 1 | 211 | 211 | Write a Rust struct `StaticSession` that implements `flowcat_core::SessionSource` for local flowcat calls without a control plane. It should be constructed with an agent `graph_spec: Value`, `seed_vars: Map<String, Value>`, and a `provider: String`. The struct must store a `brain_config: Value` and an `artifact_dir: Pa... | // SPDX-License-Identifier: Apache-2.0
//
//! [`StaticSession`] — a control-plane-free [`SessionSource`].
//!
//! flowcat's runtime resolves each call through a `SessionSource` (fetch the
//! agent config, upload recordings/transcripts, write the finalize). Embedders
//! back that with their control-plane HTTP API — bu... | nvidia/nemotron-3.5-lightning-30b-a3b |
5311e94b902460d6-0 | 5311e94b902460d6 | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-server/src/socket.rs | file | socket.rs | flowcat-server/src/socket.rs | 1 | 95 | 95 | Write a Rust struct that adapts an accepted axum `WebSocket` as a `flowcat_core::MediaSocket` for a server-side media pipeline. The struct should split the socket: the read half feeds `recv`, which loops on incoming frames, skipping ping/pong, and returns `WsIn::Text`, `WsIn::Binary`, or `WsIn::Close` as appropriate. T... | // SPDX-License-Identifier: Apache-2.0
//
//! [`AxumWsSocket`] — a flowcat-core [`MediaSocket`] over an inbound axum WebSocket.
//!
//! flowcat-core's media path is generic over `T: MediaSocket`, so the cleanest
//! server-side adapter is a direct impl over [`axum::extract::ws::WebSocket`] — no
//! tungstenite round-tr... | nvidia/nemotron-3.5-lightning-30b-a3b |
74eb047624ae84c4-0 | 74eb047624ae84c4 | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-server/src/server.rs | file | server.rs | flowcat-server/src/server.rs | 1 | 587 | 587 | I need an Axum-based HTTP server for a flowcat telephony agent that serves health probes, a Plivo media WebSocket, and a Plivo answer XML. The server should use a generic `AppState<S, B>` holding a shared session implementing `SessionSource` and a per-call brain factory for `AgentBrain`. It must have routes: `/healthz`... | // SPDX-License-Identifier: Apache-2.0
//
//! The axum HTTP server: health probes, the Plivo media WebSocket, and the Plivo
//! answer XML. Single-agent and **unauthenticated** by design (it serves one
//! configured agent with no control plane) — front it with your own ingress/auth
//! for anything public.
use std::s... | nvidia/nemotron-3.5-lightning-30b-a3b |
3b3a413db47e648e-0 | 3b3a413db47e648e | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-server/src/lib.rs | file | lib.rs | flowcat-server/src/lib.rs | 1 | 84 | 84 | I need the full `lib.rs` source file for a Rust crate that implements a config-driven single-agent server framework. The file should declare public modules `config`, `run`, `session`, and feature-gated modules `server`, `sip`, `socket`, `events`, `webrtc` behind `server-helper` and `webrtc-helper` features. It must exp... | // SPDX-License-Identifier: Apache-2.0
//
//! # flowcat-server
//!
//! A config-driven single-agent server for the Flowcat runtime: point it at a
//! YAML/JSON config describing one agent (graph + topology + transport) and run
//! that agent with **no control plane**.
//!
//! - [`config`] — the agent/server config sche... | nvidia/nemotron-3.5-lightning-30b-a3b |
e53bd0a3babb507b-0 | e53bd0a3babb507b | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-server/src/sip.rs | file | sip.rs | flowcat-server/src/sip.rs | 1 | 732 | 732 | I need a Rust module that implements generic SIP inbound/originate orchestration, defining a `SipRun` struct containing `run_id: i64` and `token: String`, a `SipInboundResolver` async trait with `resolve_inbound(&self, invite: &InboundInvite) -> Result<SipRun, FlowcatError>`, a `TopologyResolver` type alias, and a `Sip... | // SPDX-License-Identifier: Apache-2.0
//
//! Generic SIP inbound/originate orchestration — the SIP analogue of the carrier
//! media-WS path (`media_ws` + [`run_call_with`](crate::run::run_call_with)).
//!
//! flowcat-core exposes the SIP *primitives* — [`SipAgent`], [`InboundInvite`],
//! `SipTransport` — but every e... | nvidia/nemotron-3.5-lightning-30b-a3b |
a5ec2e538fd702c8-0 | a5ec2e538fd702c8 | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-services/src/llm/deepseek.rs | file | deepseek.rs | flowcat-services/src/llm/deepseek.rs | 1 | 75 | 75 | I need a Rust module that provides a DeepSeek LLM service adapter for the Flowcat framework. The type should wrap an `OpenAiLlm` and point it at DeepSeek's OpenAI-compatible API endpoint. It must implement the `LlmService` trait from `flowcat_core`, with a constructor that takes an API key and optionally a model name, ... | // SPDX-License-Identifier: Apache-2.0
//
//! **DeepSeek** LLM — a thin **(W)rapper** over [`OpenAiLlm`](super::OpenAiLlm).
//!
//! DeepSeek exposes an **OpenAI-compatible** chat-completions endpoint (verified
//! against pipecat `services/deepseek/llm.py`, which is
//! `class DeepSeekLLMService(OpenAILLMService)`), so... | nvidia/nemotron-3.5-lightning-30b-a3b |
1d50431f3fb243e8-0 | 1d50431f3fb243e8 | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-services/src/brain/mod.rs | file | mod.rs | flowcat-services/src/brain/mod.rs | 1 | 16 | 16 | I need a Rust module file for a Flowcat brain HTTP remote adapter. Please include an Apache 2.0 license header, followed by a doc comment describing remote brain adapters that implement the synchronous `flowcat_core::AgentBrain` trait, which lives in `flowcat-core` and drives conversation policy. The comment should exp... | // SPDX-License-Identifier: Apache-2.0
//
//! Remote "brain" adapters — `AgentBrain` impls that drive the conversation
//! policy from an out-of-process service over the network.
//!
//! The conversation decision-maker trait ([`flowcat_core::AgentBrain`]) is
//! synchronous and lives in `flowcat-core`. An embedder norm... | nvidia/nemotron-3.5-lightning-30b-a3b |
149b8e2817412e2c-0 | 149b8e2817412e2c | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-services/src/llm/grok.rs | file | grok.rs | flowcat-services/src/llm/grok.rs | 1 | 75 | 75 | I need a Rust source file that defines a Grok (xAI) LLM wrapper around an OpenAI-compatible API. The code should declare constants for the API base URL and default model, a struct implementing a `LlmService` trait, constructors taking an API key and model name, and delegation of `start`, `run_llm`, and `set_tools` to a... | // SPDX-License-Identifier: Apache-2.0
//
//! **Grok (xAI)** LLM — a thin **(W)rapper** over [`OpenAiLlm`](super::OpenAiLlm).
//!
//! Grok (xAI) exposes an **OpenAI-compatible** chat-completions endpoint (verified
//! against pipecat `services/grok/llm.py`, which is
//! `class GrokLLMService(OpenAILLMService)`), so thi... | nvidia/nemotron-3.5-lightning-30b-a3b |
c498a99986b5f0e4-0 | c498a99986b5f0e4 | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-services/src/llm/groq.rs | file | groq.rs | flowcat-services/src/llm/groq.rs | 1 | 75 | 75 | I need a Rust source file that defines a Groq LLM wrapper type implementing an OpenAI-compatible chat completions interface. The type should be called `GroqLlm` and wrap an `OpenAiLlm` instance, pointing at `https://api.groq.com/openai/v1` with default model `llama-3.3-70b-versatile`. It must provide constructors `new(... | // SPDX-License-Identifier: Apache-2.0
//
//! **Groq** LLM — a thin **(W)rapper** over [`OpenAiLlm`](super::OpenAiLlm).
//!
//! Groq exposes an **OpenAI-compatible** chat-completions endpoint (verified
//! against pipecat `services/groq/llm.py`, which is
//! `class GroqLLMService(OpenAILLMService)`), so this is the ref... | nvidia/nemotron-3.5-lightning-30b-a3b |
3261533ea00e79be-0 | 3261533ea00e79be | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-services/src/llm/minimax.rs | file | minimax.rs | flowcat-services/src/llm/minimax.rs | 1 | 79 | 79 | I need a Rust struct `MiniMaxLlm` that wraps `OpenAiLlm` to provide a MiniMax LLM service for the Flowcat framework. The wrapper should connect to the OpenAI-compatible API at `https://api.minimax.io/v1` with default model `MiniMax-M2.7`. It must implement the `LlmService` trait from `flowcat_core`, providing `name`, `... | // SPDX-License-Identifier: Apache-2.0
//
//! **MiniMax** LLM — a thin **(W)rapper** over [`OpenAiLlm`](super::OpenAiLlm).
//!
//! MiniMax's international API exposes an **OpenAI-compatible** chat-completions
//! endpoint at [`MINIMAX_API_BASE`] (`{base}/chat/completions`, `Authorization: Bearer`),
//! so — like Cerebr... | nvidia/nemotron-3.5-lightning-30b-a3b |
54a9295149d0dec0-0 | 54a9295149d0dec0 | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-services/src/llm/fireworks.rs | file | fireworks.rs | flowcat-services/src/llm/fireworks.rs | 1 | 75 | 75 | I need a Rust module that implements a Fireworks AI LLM service as a thin wrapper over OpenAiLlm. The module should define `FIREWORKS_API_BASE` as the API base URL string and `FIREWORKS_DEFAULT_MODEL` as the default model string. It should declare a `FireworksLlm` struct with a constructor `new(api_key: impl Into<Strin... | // SPDX-License-Identifier: Apache-2.0
//
//! **Fireworks AI** LLM — a thin **(W)rapper** over [`OpenAiLlm`](super::OpenAiLlm).
//!
//! Fireworks AI exposes an **OpenAI-compatible** chat-completions endpoint (verified
//! against pipecat `services/fireworks/llm.py`, which is
//! `class FireworksLLMService(OpenAILLMServ... | nvidia/nemotron-3.5-lightning-30b-a3b |
3b7287a981424245-0 | 3b7287a981424245 | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-services/src/llm/mistral.rs | file | mistral.rs | flowcat-services/src/llm/mistral.rs | 1 | 75 | 75 | I need a Rust module that implements a Mistral LLM service as a thin wrapper over OpenAiLlm, using the OpenAI-compatible API base `https://api.mistral.ai/v1` with default model `mistral-small-latest`. The struct should be named `MistralLlm` and provide constructors `new(api_key)` and `with_model(api_key, model)`. It mu... | // SPDX-License-Identifier: Apache-2.0
//
//! **Mistral** LLM — a thin **(W)rapper** over [`OpenAiLlm`](super::OpenAiLlm).
//!
//! Mistral exposes an **OpenAI-compatible** chat-completions endpoint (verified
//! against pipecat `services/mistral/llm.py`, which is
//! `class MistralLLMService(OpenAILLMService)`), so thi... | nvidia/nemotron-3.5-lightning-30b-a3b |
420927839b6cc177-0 | 420927839b6cc177 | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-services/src/llm/novita.rs | file | novita.rs | flowcat-services/src/llm/novita.rs | 1 | 75 | 75 | I need a Rust module that wraps OpenAiLlm to provide a Novita AI LLM service. It should define an API base URL constant and a default model constant for Novita AI's OpenAI-compatible chat completions endpoint. There should be a struct with constructors that take an API key and an optional model name, building an OpenAi... | // SPDX-License-Identifier: Apache-2.0
//
//! **Novita AI** LLM — a thin **(W)rapper** over [`OpenAiLlm`](super::OpenAiLlm).
//!
//! Novita AI exposes an **OpenAI-compatible** chat-completions endpoint (verified
//! against pipecat `services/novita/llm.py`, which is
//! `class NovitaLLMService(OpenAILLMService)`), so t... | nvidia/nemotron-3.5-lightning-30b-a3b |
14fbd3cc88287474-0 | 14fbd3cc88287474 | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-services/src/llm/ollama.rs | file | ollama.rs | flowcat-services/src/llm/ollama.rs | 1 | 75 | 75 | I need a Rust module that defines an `OllamaLlm` struct wrapping `OpenAiLlm` to provide a local Ollama LLM service backed by an OpenAI-compatible API at `http://localhost:11434/v1` with default model `llama2`. The struct must implement `LlmService` from `flowcat_core`, exposing a constructor `new(api_key)` bound to the... | // SPDX-License-Identifier: Apache-2.0
//
//! **Ollama (local)** LLM — a thin **(W)rapper** over [`OpenAiLlm`](super::OpenAiLlm).
//!
//! Ollama (local) exposes an **OpenAI-compatible** chat-completions endpoint (verified
//! against pipecat `services/ollama/llm.py`, which is
//! `class OLLamaLLMService(OpenAILLMServic... | nvidia/nemotron-3.5-lightning-30b-a3b |
a17d450c74147b8c-0 | a17d450c74147b8c | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-services/src/llm/sambanova.rs | file | sambanova.rs | flowcat-services/src/llm/sambanova.rs | 1 | 75 | 75 | Write a Rust module that provides a SambaNova LLM service as a minimal wrapper around OpenAiLlm, using an OpenAI-compatible API base URL and a default model name for llama-style inference. The code should define a `SambaNovaLlm` struct with `new` and `with_model` constructors, implement `LlmService` by delegating `name... | // SPDX-License-Identifier: Apache-2.0
//
//! **SambaNova** LLM — a thin **(W)rapper** over [`OpenAiLlm`](super::OpenAiLlm).
//!
//! SambaNova exposes an **OpenAI-compatible** chat-completions endpoint (verified
//! against pipecat `services/sambanova/llm.py`, which is
//! `class SambaNovaLLMService(OpenAILLMService)`)... | nvidia/nemotron-3.5-lightning-30b-a3b |
c1a8894b6c9b1077-0 | c1a8894b6c9b1077 | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-services/src/llm/nvidia_nim.rs | file | nvidia_nim.rs | flowcat-services/src/llm/nvidia_nim.rs | 1 | 75 | 75 | I need a Rust module that implements a thin wrapper over OpenAiLlm for NVIDIA NIM's OpenAI-compatible chat completions API. The wrapper should be configured with the base URL https://integrate.api.nvidia.com/v1 and default model nvidia/nemotron-3-nano-30b-a3b. Define a struct NvidiaNimLlm that holds an OpenAiLlm instan... | // SPDX-License-Identifier: Apache-2.0
//
//! **NVIDIA NIM** LLM — a thin **(W)rapper** over [`OpenAiLlm`](super::OpenAiLlm).
//!
//! NVIDIA NIM exposes an **OpenAI-compatible** chat-completions endpoint (verified
//! against pipecat `services/nvidia/llm.py`, which is
//! `class NimLLMService(OpenAILLMService)`), so th... | nvidia/nemotron-3.5-lightning-30b-a3b |
fd6a8ba78effdf24-0 | fd6a8ba78effdf24 | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-services/src/llm/cerebras.rs | file | cerebras.rs | flowcat-services/src/llm/cerebras.rs | 1 | 75 | 75 | I need a Rust module that implements a Cerebras LLM service as a thin wrapper around OpenAiLlm. The wrapper should use the Cerebras OpenAI-compatible API base URL and default to the model `gpt-oss-120b`. Provide a `CerebrasLlm` struct with two constructors: `new(api_key)` bound to the default model, and `with_model(api... | // SPDX-License-Identifier: Apache-2.0
//
//! **Cerebras** LLM — a thin **(W)rapper** over [`OpenAiLlm`](super::OpenAiLlm).
//!
//! Cerebras exposes an **OpenAI-compatible** chat-completions endpoint (verified
//! against pipecat `services/cerebras/llm.py`, which is
//! `class CerebrasLLMService(OpenAILLMService)`), so... | nvidia/nemotron-3.5-lightning-30b-a3b |
ed004cff32a069bb-0 | ed004cff32a069bb | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-services/src/llm/sarvam.rs | file | sarvam.rs | flowcat-services/src/llm/sarvam.rs | 1 | 75 | 75 | Implement a Rust module that provides a Sarvam LLM service as a thin wrapper around OpenAiLlm, configured with the Sarvam API base URL `https://api.sarvam.ai/v1` and default model `sarvam-30b`. The struct must expose two constructors: one taking only an API key that uses the default model, and another taking both an AP... | // SPDX-License-Identifier: Apache-2.0
//
//! **Sarvam** LLM — a thin **(W)rapper** over [`OpenAiLlm`](super::OpenAiLlm).
//!
//! Sarvam exposes an **OpenAI-compatible** chat-completions endpoint (verified
//! against pipecat `services/sarvam/llm.py`, which is
//! `class SarvamLLMService(OpenAILLMService)`), so this is... | nvidia/nemotron-3.5-lightning-30b-a3b |
0a5723372ecd9227-0 | 0a5723372ecd9227 | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-services/src/llm/openrouter.rs | file | openrouter.rs | flowcat-services/src/llm/openrouter.rs | 1 | 111 | 111 | I need a Rust module that provides an OpenRouter LLM service, wrapping an OpenAI-compatible chat completions client to work with the OpenRouter API. The module should define constants for the API base URL and default model, a struct representing the service that holds an inner OpenAI LLM implementation, and constructor... | // SPDX-License-Identifier: Apache-2.0
//
//! **OpenRouter** LLM — a thin **(W)rapper** over [`OpenAiLlm`](super::OpenAiLlm).
//!
//! OpenRouter exposes an **OpenAI-compatible** chat-completions endpoint (verified
//! against pipecat `services/openrouter/llm.py`, which is
//! `class OpenRouterLLMService(OpenAILLMServic... | nvidia/nemotron-3.5-lightning-30b-a3b |
418af6f72c4ddf3b-0 | 418af6f72c4ddf3b | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-services/src/llm/together.rs | file | together.rs | flowcat-services/src/llm/together.rs | 1 | 75 | 75 | I need a Rust type that wraps `OpenAiLlm` to serve as a Together AI-compatible LLM service for flowcat. It should be constructable with an API key and an optional model name, defaulting to `TOGETHER_DEFAULT_MODEL` (`openai/gpt-oss-20b`), and use the base URL `TOGETHER_API_BASE` (`https://api.together.xyz/v1`). The type... | // SPDX-License-Identifier: Apache-2.0
//
//! **Together AI** LLM — a thin **(W)rapper** over [`OpenAiLlm`](super::OpenAiLlm).
//!
//! Together AI exposes an **OpenAI-compatible** chat-completions endpoint (verified
//! against pipecat `services/together/llm.py`, which is
//! `class TogetherLLMService(OpenAILLMService)... | nvidia/nemotron-3.5-lightning-30b-a3b |
40b100609302ad85-0 | 40b100609302ad85 | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-services/src/llm/qwen.rs | file | qwen.rs | flowcat-services/src/llm/qwen.rs | 1 | 75 | 75 | I need a Rust module that provides a Qwen (DashScope) LLM service as a thin wrapper around OpenAiLlm, configured with the DashScope OpenAI-compatible API base URL and the `qwen-plus` default model. The module should define a `QwenLlm` struct, implement constructors `new` and `with_model` taking an API key, expose a `na... | // SPDX-License-Identifier: Apache-2.0
//
//! **Qwen (DashScope)** LLM — a thin **(W)rapper** over [`OpenAiLlm`](super::OpenAiLlm).
//!
//! Qwen (DashScope) exposes an **OpenAI-compatible** chat-completions endpoint (verified
//! against pipecat `services/qwen/llm.py`, which is
//! `class QwenLLMService(OpenAILLMServic... | nvidia/nemotron-3.5-lightning-30b-a3b |
154829fcb4e2e64e-0 | 154829fcb4e2e64e | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-services/src/observability/otel.rs | file | otel.rs | flowcat-services/src/observability/otel.rs | 1 | 447 | 447 | I need a Rust module that implements an OpenTelemetry exporter for a pipeline framework. The module must define a struct `OtelSpan` holding a span name and a vector of `KeyValue` attributes, and a trait `OtelSink` with an `export` method. It should provide an in-memory `RecordingOtelSink` for testing and a `TracerOtelS... | // SPDX-License-Identifier: Apache-2.0
//
//! OpenTelemetry exporter (behind `obs-otel`).
//!
//! A [`FrameObserver`](flowcat_core::observer::FrameObserver) that turns the
//! pipeline's [`Frame::Metrics`](flowcat_core::Frame::Metrics) (and error) stream
//! into OpenTelemetry spans, following pipecat's tracing semanti... | nvidia/nemotron-3.5-lightning-30b-a3b |
9aa0056d564cb097-0 | 9aa0056d564cb097 | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-services/src/llm/speaches.rs | file | speaches.rs | flowcat-services/src/llm/speaches.rs | 1 | 75 | 75 | Write a Rust source file for a flowcat LLM module that implements a self-hosted, OpenAI-compatible Speaches wrapper. The module must define a constant `SPEACHES_API_BASE` set to `http://localhost:11434/v1` and `SPEACHES_DEFAULT_MODEL` set to `gpt-4o`. Define a struct `SpeachesLlm` wrapping `OpenAiLlm` with constructors... | // SPDX-License-Identifier: Apache-2.0
//
//! **Speaches (self-hosted, OpenAI-compatible)** LLM — a thin **(W)rapper** over [`OpenAiLlm`](super::OpenAiLlm).
//!
//! Speaches (self-hosted, OpenAI-compatible) exposes an **OpenAI-compatible** chat-completions endpoint (verified
//! against pipecat `services/speaches/llm.p... | nvidia/nemotron-3.5-lightning-30b-a3b |
95deaf15156b679b-0 | 95deaf15156b679b | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-services/src/llm/nebius.rs | file | nebius.rs | flowcat-services/src/llm/nebius.rs | 1 | 75 | 75 | I need a Rust source file that defines a `NebiusLlm` struct wrapping `OpenAiLlm` to provide a Nebius LLM service with an OpenAI-compatible API. The struct should be constructable via `new(api_key)` using the default model `openai/gpt-oss-120b` and base URL `https://api.tokenfactory.nebius.com/v1`, or via `with_model(ap... | // SPDX-License-Identifier: Apache-2.0
//
//! **Nebius** LLM — a thin **(W)rapper** over [`OpenAiLlm`](super::OpenAiLlm).
//!
//! Nebius exposes an **OpenAI-compatible** chat-completions endpoint (verified
//! against pipecat `services/nebius/llm.py`, which is
//! `class NebiusLLMService(OpenAILLMService)`), so this is... | nvidia/nemotron-3.5-lightning-30b-a3b |
0c83e918c0a7ea30-0 | 0c83e918c0a7ea30 | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-services/src/observability/mod.rs | file | mod.rs | flowcat-services/src/observability/mod.rs | 1 | 32 | 32 | I need a Rust module that serves as a gateway for networked observability exporters, wiring the `Frame::Metrics` stream from `flowcat_core::observer::FrameObserver` out to external sinks. The module must have three feature-gated sections: `obs-otel` for OpenTelemetry exporters (`OtelExporter`, `OtelSink`, `OtelSpan`, `... | // SPDX-License-Identifier: Apache-2.0
//
//! Networked observability exporters.
//!
//! These [`FrameObserver`](flowcat_core::observer::FrameObserver) impls wire the
//! `Frame::Metrics` stream out to external sinks — they pull network deps
//! (`reqwest`/OTel SDK) so they live here, NOT in flowcat-core (the trait +
/... | nvidia/nemotron-3.5-lightning-30b-a3b |
6e9ebb6d8e220430-0 | 6e9ebb6d8e220430 | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-services/src/observability/langfuse.rs | file | langfuse.rs | flowcat-services/src/observability/langfuse.rs | 1 | 396 | 396 | I need a Rust module that implements a Langfuse exporter as a FrameObserver for an LLM pipeline. The observer should accumulate input messages from LlmContext frames, concatenate streamed output from LlmText frames, and capture LlmUsage token data from Metrics frames. It must flush a LangfuseGeneration on LlmResponseEn... | // SPDX-License-Identifier: Apache-2.0
//
//! Langfuse exporter (behind `obs-langfuse`).
//!
//! A [`FrameObserver`](flowcat_core::observer::FrameObserver) that assembles
//! per-turn LLM **generations** from the pipeline frame stream and ships them to
//! Langfuse. It folds:
//!
//! - [`Frame::LlmContext`](flowcat_cor... | nvidia/nemotron-3.5-lightning-30b-a3b |
f6687d2668d7ba3d-0 | f6687d2668d7ba3d | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-services/src/observability/sentry.rs | file | sentry.rs | flowcat-services/src/observability/sentry.rs | 1 | 382 | 382 | I need a Rust module that implements a `FrameObserver` for a pipeline framework. The module should capture pipeline errors and metric transactions and report them to a Sentry-compatible endpoint via an injected `SentrySink` trait. Specifically, it must handle `Frame::Error` events by mapping a `fatal` boolean to a Sent... | // SPDX-License-Identifier: Apache-2.0
//
//! Sentry exporter (behind `obs-sentry`).
//!
//! A [`FrameObserver`](flowcat_core::observer::FrameObserver) that reports
//! pipeline **errors** (and TTFB/processing **transactions**, mirroring pipecat's
//! `processors/metrics/sentry.py` `SentryMetrics`) to Sentry.
//!
//! #... | nvidia/nemotron-3.5-lightning-30b-a3b |
84747c4db2ecac6e-0 | 84747c4db2ecac6e | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-services/src/realtime/inworld.rs | file | inworld.rs | flowcat-services/src/realtime/inworld.rs | 1 | 135 | 135 | Write a Rust module that defines an `InworldRealtime` struct wrapping `OpenAiRealtime` to provide an Inworld Realtime speech-to-speech client. The client must connect to `wss://api.inworld.ai/api/v1/realtime/session` using `Authorization: Bearer` auth with an API key. It should be constructed via `new(api_key)` and sup... | // SPDX-License-Identifier: Apache-2.0
//
//! **Inworld Realtime** (speech-to-speech) client.
//!
//! Inworld's Realtime endpoint speaks an **OpenAI-Realtime-style** event
//! protocol (`session.update` / `input_audio_buffer.append` / `response.*`) over
//! `wss://api.inworld.ai/api/v1/realtime/session` with `Authoriza... | nvidia/nemotron-3.5-lightning-30b-a3b |
0c77ce65610d1da2-0 | 0c77ce65610d1da2 | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-services/src/realtime/grok.rs | file | grok.rs | flowcat-services/src/realtime/grok.rs | 1 | 129 | 129 | I'm building a Rust realtime LLM service client for xAI's Grok model that adheres to the OpenAI Realtime wire protocol. I need a module that wraps an `OpenAiRealtime` instance, hardcodes the xAI base URL `wss://api.x.ai/v1/realtime`, and exposes a constructor taking an API key plus a method to override the base URL. Th... | // SPDX-License-Identifier: Apache-2.0
//
//! **xAI Grok Realtime** (speech-to-speech) client.
//!
//! xAI's Realtime endpoint speaks the **OpenAI Realtime wire protocol** over
//! `wss://api.x.ai/v1/realtime?model=<model>` with `Authorization: Bearer <key>`
//! auth (the reference `GrokRealtimeLLMService` aliases the ... | nvidia/nemotron-3.5-lightning-30b-a3b |
e21cdd20f07e01cc-0 | e21cdd20f07e01cc | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-services/src/realtime/azure.rs | file | azure.rs | flowcat-services/src/realtime/azure.rs | 1 | 138 | 138 | I need a Rust module that implements an Azure OpenAI Realtime client by wrapping the OpenAiRealtime type. The struct should be named `AzureRealtime` and be initialized with an API key and a full Azure WebSocket endpoint URL (including `?api-version` and `?deployment` query parameters). It must configure the inner clien... | // SPDX-License-Identifier: Apache-2.0
//
//! **Azure OpenAI Realtime** (speech-to-speech) client.
//!
//! Azure's Realtime endpoint speaks the **same wire protocol** as OpenAI
//! Realtime, differing only in (a) the endpoint URL — a full Azure WSS URL that
//! already carries `?api-version=…&deployment=…` — and (b) au... | nvidia/nemotron-3.5-lightning-30b-a3b |
08845738acb096e9-0 | 08845738acb096e9 | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-services/src/stt/mod.rs | file | mod.rs | flowcat-services/src/stt/mod.rs | 1 | 103 | 103 | I need a Rust module file that re-exports multiple speech-to-text provider implementations, each behind a Cargo feature flag. The module should implement the `SttService` trait from a core crate, with providers organized by protocol family: streaming-WebSocket (following the Deepgram JSON schema template), Whisper-HTTP... | // SPDX-License-Identifier: Apache-2.0
//
//! Streaming speech-to-text providers.
//!
//! Impls of [`SttService`](flowcat_core::service::SttService). The reference impl
//! (**Deepgram**, streaming WebSocket) sits behind `stt-deepgram`; all other providers
//! follow the same pattern. Each provider is `dep:`-feature-ga... | nvidia/nemotron-3.5-lightning-30b-a3b |
5f9f0526d1c086fa-0 | 5f9f0526d1c086fa | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-services/src/realtime/mod.rs | file | mod.rs | flowcat-services/src/realtime/mod.rs | 1 | 60 | 60 | I need a Rust module file that organizes realtime speech-to-speech providers for a crate. The file should feature-gate six submodules—OpenAI, Azure, Grok, Inworld, Ultravox, and Nova Sonic—each behind Cargo features `realtime-openai`, `realtime-azure`, `realtime-grok`, `realtime-inworld`, `realtime-ultravox`, and `real... | // SPDX-License-Identifier: Apache-2.0
//
//! Realtime / speech-to-speech providers.
//!
//! Home for the **NEW** realtime providers only. The
//! [`RealtimeLlmService`](flowcat_core::service::RealtimeLlmService) trait is
//! frozen in flowcat-core; each module here impls it behind its own feature.
//!
//! **Gemini is ... | nvidia/nemotron-3.5-lightning-30b-a3b |
774673346698b698-0 | 774673346698b698 | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-transports/src/avatar/mod.rs | file | mod.rs | flowcat-transports/src/avatar/mod.rs | 1 | 6 | 6 | Generate a Rust module file for avatar transports that documents talking-head overlays on the audio leg. The file should start with an Apache 2.0 SPDX license header, followed by an inner doc comment stating it is a provider-agnostic home where Tavus, HeyGen, Simli, and LemonSlice are added as dep-gated submodules, ens... | // SPDX-License-Identifier: Apache-2.0
//
//! Avatar transports (Tavus / HeyGen / Simli / LemonSlice) that overlay a
//! talking-head on the audio leg. Always-present doc-only home; each provider
//! submodule and its `dep:`-gated feature is added when implemented (the module
//! home pre-exists so there is no `mod`-de... | nvidia/nemotron-3.5-lightning-30b-a3b |
c291d6d912592740-0 | c291d6d912592740 | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-telephony/src/lib.rs | file | lib.rs | flowcat-telephony/src/lib.rs | 1 | 93 | 93 | I'm writing a Rust library that provides carrier-specific WebSocket FrameSerializer implementations of the MediaSerializer trait from flowcat-core, along with DTMF detection and encoding. The library should feature multiple behind-feature carrier modules (Twilio, Telnyx, Plivo, Exotel, Vonage, Genesys, Asterisk, Cloudo... | // SPDX-License-Identifier: Apache-2.0
//
//! # flowcat-telephony
//!
//! Per-carrier WebSocket **`FrameSerializer`s** + DTMF for the Flowcat runtime:
//! Twilio, Telnyx, Plivo, Exotel, Vonage, Genesys, Asterisk, Cloudonix, Vobiz.
//!
//! Each serializer impls the frozen
//! [`MediaSerializer`](flowcat_core::MediaSeria... | nvidia/nemotron-3.5-lightning-30b-a3b |
34e487a09f6278de-0 | 34e487a09f6278de | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-transports/src/daily.rs | file | daily.rs | flowcat-transports/src/daily.rs | 1 | 6 | 6 | I need the Apache-2.0 license header and introductory doc comments for a Rust module that serves as a stub `MediaTransport` for Daily's media infrastructure, using `reqwest` for REST signaling and conditionalized behind a `daily` feature flag. The description should reference `flowcat_core::MediaTransport` and note the... | // SPDX-License-Identifier: Apache-2.0
//
//! Daily transport (stub — not yet implemented).
//!
//! A [`MediaTransport`](flowcat_core::MediaTransport) over Daily's media
//! infrastructure (REST signaling via `reqwest`). Behind the `daily` feature. | nvidia/nemotron-3.5-lightning-30b-a3b |
6d2b3d94954a19cc-0 | 6d2b3d94954a19cc | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-transports/src/lib.rs | file | lib.rs | flowcat-transports/src/lib.rs | 1 | 60 | 60 | I need a Rust library crate called `flowcat-transports` that provides feature-gated concrete media transports for the Flowcat runtime, including str0m WebRTC+Opus behind `webrtc-str0m`, a WebSocket transport behind `ws`, local mic/speaker behind `local`, Daily behind `daily`, LiveKit behind `livekit`, and avatar stubs ... | // SPDX-License-Identifier: Apache-2.0
//
//! # flowcat-transports
//!
//! Concrete media **transports** for the Flowcat runtime: str0m WebRTC + Opus,
//! a WebSocket transport, Daily/LiveKit, a local mic/speaker, and avatar
//! transports.
//!
//! The transport-agnostic seams —
//! [`MediaTransport`](flowcat_core::Med... | nvidia/nemotron-3.5-lightning-30b-a3b |
e114b782b5d355f6-0 | e114b782b5d355f6 | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-transports/src/livekit.rs | file | livekit.rs | flowcat-transports/src/livekit.rs | 1 | 6 | 6 | I need a Rust module file for a LiveKit transport in the Flowcat project. It should be a stub implementation that references `flowcat_core::MediaTransport`, protected by a `livekit` feature flag. The file must begin with an `SPDX-License-Identifier: Apache-2.0` header, and include documentation comments describing it a... | // SPDX-License-Identifier: Apache-2.0
//
//! LiveKit transport (stub — not yet implemented).
//!
//! A [`MediaTransport`](flowcat_core::MediaTransport) over LiveKit. Behind the
//! `livekit` feature (its SDK dep is added when implemented). | nvidia/nemotron-3.5-lightning-30b-a3b |
35ec5ec0b0a27572-0 | 35ec5ec0b0a27572 | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-transports/src/local.rs | file | local.rs | flowcat-transports/src/local.rs | 1 | 96 | 96 | I need a stub `LocalTransport` type that implements `flowcat_core::transport::MediaTransport` for a CLI demo harness behind a `local` feature. The type should be initialized with a carrier sample rate and track whether it has started. Its `recv` method must return `MediaIn::StreamStart { call_id: "local" }` on the firs... | // SPDX-License-Identifier: Apache-2.0
//
//! Local mic/speaker transport (CLI demo harness) — **stub**.
//!
//! A [`MediaTransport`](flowcat_core::MediaTransport) over the local audio
//! device, for the CLI demo harness. Behind the `local` feature.
//!
//! ## Why this is a stub
//!
//! A real local device leg needs `... | nvidia/nemotron-3.5-lightning-30b-a3b |
6b27fdca26f90a17-0 | 6b27fdca26f90a17 | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-services/src/tts/mod.rs | file | mod.rs | flowcat-services/src/tts/mod.rs | 1 | 153 | 153 | I need a complete Rust module file that organizes and exports all streaming text-to-speech provider implementations for a service framework. The file should featurecfg-gated modules for multiple TTS vendors, each with a builder type, and re-export the main provider structs at the crate root. It must group providers int... | // SPDX-License-Identifier: Apache-2.0
//
//! Streaming text-to-speech providers.
//!
//! Impls of [`TtsService`](flowcat_core::service::TtsService). Cartesia is the
//! reference streaming-WebSocket impl behind `tts-cartesia`; the remaining providers
//! fan out from there. Each provider is `dep:`-feature-gated so the... | nvidia/nemotron-3.5-lightning-30b-a3b |
3ad1ee79f1787660-0 | 3ad1ee79f1787660 | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-services/src/tts/xai.rs | file | xai.rs | flowcat-services/src/tts/xai.rs | 1 | 88 | 88 | I need a Rust source file that implements an xAI TTS service wrapper around the OpenAI TTS HTTP client for the flowcat project. It should configure an OpenAI TTS client to use xAI's API endpoint `https://api.x.ai/v1/tts`, with default voice `eve`, sample rate 24 kHz, and service name `xai`. The wrapper must implement t... | // SPDX-License-Identifier: Apache-2.0
//
//! **xAI** TTS — a **(W)rapper** over the OpenAI-TTS-HTTP family.
//!
//! xAI's batch HTTP TTS (`XAIHttpTTSService`) shares the OpenAI family transport —
//! a `Authorization: Bearer <key>` POST that returns raw `pcm` bytes — but at its
//! own endpoint `https://api.x.ai/v1/tt... | nvidia/nemotron-3.5-lightning-30b-a3b |
234b899b02046333-0 | 234b899b02046333 | AreevAI/flowcat | https://github.com/AreevAI/flowcat | 9eb2999c3325859d0b9afd233b97f22774e577df | Apache-2.0 | flowcat-services/src/tts/groq.rs | file | groq.rs | flowcat-services/src/tts/groq.rs | 1 | 91 | 91 | I need a Rust struct that integrates Groq's TTS API into the flowcat framework. It should wrap an OpenAI-compatible TTS client, configured to point at https://api.groq.com/openai/v1, use the model canopylabs/orpheus-v1-english, operate at 24 kHz sample rate, and return audio as WAV containers. The struct should be init... | // SPDX-License-Identifier: Apache-2.0
//
//! **Groq** TTS — a **(W)rapper** over the OpenAI-TTS-HTTP family.
//!
//! Groq's TTS is the OpenAI `/audio/speech` wire shape (`Authorization: Bearer`,
//! `{input,model,voice,response_format}`) at `https://api.groq.com/openai/v1`,
//! differing only in `base_url`, default mo... | nvidia/nemotron-3.5-lightning-30b-a3b |
19e5aaaf3681f742-0 | 19e5aaaf3681f742 | cortex/ripasso | https://github.com/cortex/ripasso | 25f855dfc3232e6e2a641896b5f9773d76311004 | GPL-3.0-only | crates/ripasso/src/password_generator.rs | file | password_generator.rs | crates/ripasso/src/password_generator.rs | 1 | 37 | 37 | I need a Rust function that generates a password string of a given length, supporting two categories of ASCII characters: one limited to standard printable ASCII (33–126) and another covering extended ASCII up to 255. The function should use the `rand` crate's `RngExt` trait to randomly select characters within the spe... | use rand::RngExt;
#[non_exhaustive]
#[derive(Debug, Copy, Clone)]
pub enum PasswordGenerationCategory {
AsciiOnly,
AsciiExtended,
}
/// generates a password with the specified `length`.
///
/// # Panics
/// If the random function returns a value outside the
/// specified range, this can't happen.
#[must_use]
... | nvidia/nemotron-3.5-lightning-30b-a3b |
71d4ec2294328398-0 | 71d4ec2294328398 | cortex/ripasso | https://github.com/cortex/ripasso | 25f855dfc3232e6e2a641896b5f9773d76311004 | GPL-3.0-only | crates/ripasso/src/passphrase_generator.rs | file | passphrase_generator.rs | crates/ripasso/src/passphrase_generator.rs | 1 | 33 | 33 | I need a Rust function that generates a passphrase of a specified word count by randomly selecting words from the EFF large wordlist. The function should accept `word_count: usize` and return `Result<Vec<String>>`, failing if the wordlist cannot be loaded or is empty. It must use `rand::rng` and `IndexedRandom` for sam... | use rand::prelude::IndexedRandom;
use crate::{error::Result, pass::Error};
static WORDLIST: &str = include_str!("wordlists/eff_large.wordlist");
/// Returns a pass phrase consisting of `word_count` number of
///words from the large wordlist from EFF.
///
/// # Errors
/// Fails if the loading of the wordlist fails.
p... | nvidia/nemotron-3.5-lightning-30b-a3b |
b2395c8d822f2428-0 | b2395c8d822f2428 | cortex/ripasso | https://github.com/cortex/ripasso | 25f855dfc3232e6e2a641896b5f9773d76311004 | GPL-3.0-only | crates/ripasso/benches/library_benchmark.rs | file | library_benchmark.rs | crates/ripasso/benches/library_benchmark.rs | 1 | 67 | 67 | Write a Criterion-based micro-benchmark that measures the time to populate a password list from a test archive. The setup must unpack a gzipped tar archive into a temporary directory, create a `ripasso::PasswordStore` configured with `CryptoImpl::GpgMe` and an empty master password, call `all_passwords()` and assert th... | use std::{fs::File, path::PathBuf};
use criterion::{Criterion, criterion_group, criterion_main};
use flate2::read::GzDecoder;
use ripasso::{crypto::CryptoImpl, pass};
use tar::Archive;
fn unpack_tar_gz(mut base_path: PathBuf, tar_gz_name: &str) -> Result<(), std::io::Error> {
let target = format!("{}", base_path.... | nvidia/nemotron-3.5-lightning-30b-a3b |
c7196b9a10264dc1-0 | c7196b9a10264dc1 | cortex/ripasso | https://github.com/cortex/ripasso | 25f855dfc3232e6e2a641896b5f9773d76311004 | GPL-3.0-only | crates/ripasso/src/git.rs | file | git.rs | crates/ripasso/src/git.rs | 1 | 500 | 500 | I need a Rust module for a password store that initializes a git repository and provides functions to add, remove, or move password files, committing those changes to git with optional GPG signing. The module should support pushing and pulling to a remote with SSH key agent authentication, verify commit signatures agai... | use std::{
fmt::Display,
path::{Path, PathBuf},
str,
};
use chrono::{DateTime, Local, TimeZone};
use git2::{Oid, Repository};
use crate::{
crypto::{Crypto, FindSigningFingerprintStrategy, VerificationError},
error::{Error, Result},
pass::{PasswordEntry, PasswordStore, RepositoryStatus, to_resu... | nvidia/nemotron-3.5-lightning-30b-a3b |
9aaeda2f81dd770f-0 | 9aaeda2f81dd770f | cortex/ripasso | https://github.com/cortex/ripasso | 25f855dfc3232e6e2a641896b5f9773d76311004 | GPL-3.0-only | crates/ripasso/src/crypto.rs | file | crypto.rs | crates/ripasso/src/crypto.rs | 1 | 1,071 | 1,071 | I need a Rust module for PGP cryptographic operations that supports both gpgme and sequoia backends, defining a Crypto trait with decrypt_string, encrypt_string, sign_string, and verify_sign methods, along with key management, fingerprint parsing (v4/v6), recipient handling, and trust level computation. The module must... | use std::{
collections::HashMap,
fmt::{Display, Formatter, Write},
fs,
fs::File,
io::Write as IoWrite,
path::Path,
sync::Arc,
};
use hex::FromHex;
use sequoia_openpgp::{
Cert, KeyHandle, KeyID,
crypto::SessionKey,
parse::{
Parse,
stream::{
DecryptionH... | nvidia/nemotron-3.5-lightning-30b-a3b |
3fd718327105d4e8-0 | 3fd718327105d4e8 | cortex/ripasso | https://github.com/cortex/ripasso | 25f855dfc3232e6e2a641896b5f9773d76311004 | GPL-3.0-only | crates/ripasso/src/error.rs | file | error.rs | crates/ripasso/src/error.rs | 1 | 102 | 102 | Write a Rust module that defines a comprehensive error type for a library. The error type should be a non-exhaustive enum wrapping errors from arboard, git2, gpgme, reqwest, anyhow, hex, chrono, totp-rs, config, toml, glob, and standard library errors (io, path, utf8, fmt, string). It must implement From traits for &st... | use std::{io, path, str::Utf8Error, string, sync::PoisonError};
use hex::FromHexError;
use thiserror::Error;
/// An enum that contains the different types of errors that the library returns as part of Result's.
#[non_exhaustive]
#[derive(Error, Debug)]
pub enum Error {
Clipboard(#[from] arboard::Error),
Io(#[... | nvidia/nemotron-3.5-lightning-30b-a3b |
9cfa9e72bd6b4006-0 | 9cfa9e72bd6b4006 | cortex/ripasso | https://github.com/cortex/ripasso | 25f855dfc3232e6e2a641896b5f9773d76311004 | GPL-3.0-only | crates/ripasso/src/lib.rs | file | lib.rs | crates/ripasso/src/lib.rs | 1 | 21 | 21 | I need the library root file for a Rust crate that implements a pass directory manager compatible with passwordstore.org. The crate should support encryption via `gpgme` or `sequoia` and git integration via `libgit2`. Please define the module structure with exact doc comments: a `crypto` module that handles all encrypt... | //! This implements a handling of a pass directory compatible with <https://www.passwordstore.org/> .
//! The encryption is handled by `GPGme` or `sequoia` and the git integration is with libgit2.
/// This is the library part that handles all encryption and decryption
pub mod crypto;
/// All functions and structs rela... | nvidia/nemotron-3.5-lightning-30b-a3b |
5194cc2489a109ed-0 | 5194cc2489a109ed | cortex/ripasso | https://github.com/cortex/ripasso | 25f855dfc3232e6e2a641896b5f9773d76311004 | GPL-3.0-only | crates/ripasso-gtk/build.rs | file | build.rs | crates/ripasso-gtk/build.rs | 1 | 7 | 7 | I need to compile GLib resource archives for my GTK-based Rust application as part of the build script. Please generate the `main` function for `build.rs` that invokes `glib_build_tools::compile_resources` with the resource directory `src/resources`, the XML definition at `src/resources/resources.gresource.xml`, and ou... | fn main() {
glib_build_tools::compile_resources(
&["src/resources"],
"src/resources/resources.gresource.xml",
"ripasso-gtk.gresource",
);
} | nvidia/nemotron-3.5-lightning-30b-a3b |
167725de1facb46c-0 | 167725de1facb46c | cortex/ripasso | https://github.com/cortex/ripasso | 25f855dfc3232e6e2a641896b5f9773d76311004 | GPL-3.0-only | crates/ripasso-cursive/src/helpers.rs | file | helpers.rs | crates/ripasso-cursive/src/helpers.rs | 1 | 98 | 98 | I need a Rust module of helper functions for a cursive-based terminal UI password manager. The module should provide: a function to display an error dialog that matches on pass::Error variants (especially RecipientNotInKeyRing), uses a catalog lookup for multilingual messages, and dismisses via the Escape key; a functi... | /* Ripasso - a simple password manager
Copyright (C) 2019-2020 Joakim Lundborg, Alexander Kjäll
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, version 3 of the License.
This pr... | nvidia/nemotron-3.5-lightning-30b-a3b |
e01415b41861129c-0 | e01415b41861129c | cortex/ripasso | https://github.com/cortex/ripasso | 25f855dfc3232e6e2a641896b5f9773d76311004 | GPL-3.0-only | crates/ripasso-cursive/build.rs | file | build.rs | crates/ripasso-cursive/build.rs | 1 | 156 | 156 | I need a Rust build script that generates a manual page and processes translation files for a command-line tool. The script should use the `man` crate to create a `Manual` instance with a specified title, author names and email addresses, a help flag, and a description string. It must add three custom sections: one det... | use std::{io::prelude::*, process::Command};
fn generate_man_page() -> String {
man::prelude::Manual::new("ripasso-cursive")
.about("A password manager that uses the file format of the standard unix password manager 'pass', implemented in rust.")
.author(man::prelude::Author::new("Joakim Lundborg")... | nvidia/nemotron-3.5-lightning-30b-a3b |
5b3738f96f903320-0 | 5b3738f96f903320 | cortex/ripasso | https://github.com/cortex/ripasso | 25f855dfc3232e6e2a641896b5f9773d76311004 | GPL-3.0-only | crates/ripasso-cursive/src/wizard.rs | file | wizard.rs | crates/ripasso-cursive/src/wizard.rs | 1 | 157 | 157 | I need a Rust module for a cursive-based initialization wizard for a password manager. The wizard should display a welcome dialog asking the user if they want to create a new password store directory. If the user agrees, it should prompt for a GPG key ID, create the store directory (defaulting to $HOME/.password-store ... | /* Ripasso - a simple password manager
Copyright (C) 2019-2020 Joakim Lundborg, Alexander Kjäll
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, version 3 of the License.
This pr... | nvidia/nemotron-3.5-lightning-30b-a3b |
6dea82eae3fdfb1a-0 | 6dea82eae3fdfb1a | cortex/ripasso | https://github.com/cortex/ripasso | 25f855dfc3232e6e2a641896b5f9773d76311004 | GPL-3.0-only | crates/ripasso-gtk/src/utils.rs | file | utils.rs | crates/ripasso-gtk/src/utils.rs | 1 | 38 | 38 | I need two Rust functions using gtk4 and libadwaita to display error dialogs. The first, `error_dialog`, should take a reference to `ripasso::pass::Error` and a `gtk4::Widget` that implements `IsA<gtk4::Widget>`, and show an `AlertDialog` transient for that widget with heading 'Application Error' and the error message ... | use std::sync::{Arc, Mutex};
use gtk4::prelude::{Cast, IsA};
use libadwaita::{AlertDialog, prelude::*};
use ripasso::pass::{Error, PasswordStore};
#[derive(Clone, glib::SharedBoxed)]
#[shared_boxed_type(name = "PasswordStoreBoxed")]
pub struct PasswordStoreBoxed(pub Arc<Mutex<PasswordStore>>);
pub fn error_dialog(er... | nvidia/nemotron-3.5-lightning-30b-a3b |
e9f3f9c94e3e12d6-0 | e9f3f9c94e3e12d6 | cortex/ripasso | https://github.com/cortex/ripasso | 25f855dfc3232e6e2a641896b5f9773d76311004 | GPL-3.0-only | crates/ripasso-gtk/src/window/imp.rs | file | imp.rs | crates/ripasso-gtk/src/window/imp.rs | 1 | 97 | 97 | I need a Rust source file implementing a GTK4 application window with a CompositeTemplate from a GResource UI file. The window must contain template children for an Entry, a ListBox for passwords, a ListBox for collections, a NavigationSplitView, and a Stack. It should track state with a OnceCell of gio::ListStore, a R... | use std::{cell::RefCell, path::PathBuf};
use glib::{Propagation, subclass::InitializingObject};
use gtk4::{
CompositeTemplate, Entry, FilterListModel, ListBox, Stack, gio, glib, glib::SignalHandlerId,
};
use libadwaita::{NavigationSplitView, subclass::prelude::*};
use once_cell::sync::OnceCell;
use crate::collect... | nvidia/nemotron-3.5-lightning-30b-a3b |
4a43dc1f0309d4ec-0 | 4a43dc1f0309d4ec | cortex/ripasso | https://github.com/cortex/ripasso | 25f855dfc3232e6e2a641896b5f9773d76311004 | GPL-3.0-only | crates/ripasso-gtk/src/password_object/imp.rs | file | imp.rs | crates/ripasso-gtk/src/password_object/imp.rs | 1 | 119 | 119 | I need a complete Rust ObjectImpl for a GObject subclass named PasswordObject in a GTK4/rippasso application. The struct holds RefCell<PasswordEntry> and RefCell<Arc<Mutex<PasswordStore>>>. I need six ParamSpec properties: name (String), path (String converted to PathBuf), committed-by (Option<String>), updated (date f... | use std::{
cell::RefCell,
path::PathBuf,
sync::{Arc, Mutex},
};
use chrono::{DateTime, Local};
use glib::{ParamSpec, ParamSpecBoxed, ParamSpecString, Value};
use gtk4::glib;
use libadwaita::{prelude::*, subclass::prelude::*};
use once_cell::sync::Lazy;
use ripasso::pass::{PasswordEntry, PasswordStore};
us... | nvidia/nemotron-3.5-lightning-30b-a3b |
83659739257c6c03-0 | 83659739257c6c03 | cortex/ripasso | https://github.com/cortex/ripasso | 25f855dfc3232e6e2a641896b5f9773d76311004 | GPL-3.0-only | crates/ripasso-gtk/src/collection_object/imp.rs | file | imp.rs | crates/ripasso-gtk/src/collection_object/imp.rs | 1 | 93 | 93 | I need a Rust implementation of a GObject `ObjectImpl` for a GTK4-based collection object. The struct should hold a title string, a list store of passwords, a thread-safe password store, and a user config directory path. I need the `ObjectSubclass` trait named `RipassoCollectionObject`, and the `ObjectImpl` to define f... | use std::{
cell::RefCell,
path::PathBuf,
sync::{Arc, Mutex},
};
use glib::{ParamSpec, ParamSpecString, Value};
use gtk4::{
gio, glib,
glib::{ParamSpecBoxed, ParamSpecObject},
};
use libadwaita::{prelude::*, subclass::prelude::*};
use once_cell::sync::{Lazy, OnceCell};
use ripasso::pass::PasswordSto... | nvidia/nemotron-3.5-lightning-30b-a3b |
082cfb2602db1cf6-0 | 082cfb2602db1cf6 | cortex/ripasso | https://github.com/cortex/ripasso | 25f855dfc3232e6e2a641896b5f9773d76311004 | GPL-3.0-only | crates/ripasso-gtk/src/password_object/mod.rs | file | mod.rs | crates/ripasso-gtk/src/password_object/mod.rs | 1 | 65 | 65 | I'm implementing a `PasswordObject` glib `Object` subclass for a Rust GTK4 module. I need a `new` method that accepts `name: String`, `path: PathBuf`, `updated: DateTime<Local>`, `committed_by: String`, and `store: Arc<Mutex<PasswordStore>>`, and builds the object using `glib::Object::builder`, setting properties for `... | mod imp;
use std::{
path::PathBuf,
sync::{Arc, Mutex},
};
use chrono::{DateTime, Local};
use glib::Object;
use gtk4::glib;
use libadwaita::subclass::prelude::*;
use ripasso::pass::{Error, PasswordEntry, PasswordStore};
use crate::utils::{PasswordStoreBoxed, error_dialog_standalone};
glib::wrapper! {
pub... | nvidia/nemotron-3.5-lightning-30b-a3b |
9936f79183e025d0-0 | 9936f79183e025d0 | cortex/ripasso | https://github.com/cortex/ripasso | 25f855dfc3232e6e2a641896b5f9773d76311004 | GPL-3.0-only | crates/ripasso-gtk/src/window/mod.rs | file | mod.rs | crates/ripasso-gtk/src/window/mod.rs | 1 | 590 | 590 | I need a Rust module implementing the Window type for a GTK4/libadwaita-based password manager called ripasso. The window should manage collections of passwords in a pass-compatible format, display them with filtering and selection, and support actions like git push/pull, PGP certificate download, and creating new coll... | mod imp;
use std::{
collections::HashMap,
path::{Path, PathBuf},
sync::{Arc, Mutex},
};
use glib::{Object, clone};
use gtk4::{
AboutDialog, CustomFilter, Entry, FilterListModel, Label, ListBox, ListBoxRow, NoSelection,
SelectionMode, gio, glib, glib::BindingFlags, pango,
};
use libadwaita::{Action... | nvidia/nemotron-3.5-lightning-30b-a3b |
17fc8c57c9352206-0 | 17fc8c57c9352206 | cortex/ripasso | https://github.com/cortex/ripasso | 25f855dfc3232e6e2a641896b5f9773d76311004 | GPL-3.0-only | crates/ripasso-gtk/src/main.rs | file | main.rs | crates/ripasso-gtk/src/main.rs | 1 | 40 | 40 | I need a Rust main.rs for a GTK4 application using libadwaita that registers a GResource file, sets the application ID to com.github.cortex.ripasso-gtk, and on startup binds Ctrl+f to win.git-pull, Ctrl+g to win.git-push, and Ctrl+p to win.pgp-download. On activation, it should instantiate and present a custom main win... | mod collection_object;
mod password_object;
mod utils;
mod window;
use gtk4::{gio, glib};
use libadwaita::prelude::*;
use window::Window;
static APP_ID: &str = "com.github.cortex.ripasso-gtk";
fn main() -> glib::ExitCode {
// ripasso-gtk.gresource is produced in the build.rs file
gio::resources_register_incl... | nvidia/nemotron-3.5-lightning-30b-a3b |
78908fd17db385e4-0 | 78908fd17db385e4 | brentongunning/rust-sv | https://github.com/brentongunning/rust-sv | f2c9e939b3da4bca4d6a9753c954426682c5a43b | MIT | src/lib.rs | file | lib.rs | src/lib.rs | 1 | 25 | 25 | I need a Rust library root file for a Bitcoin SV project that serves as the foundation for building applications. It should include a top-level documentation comment describing its purpose, declare external crates essential for cryptography, networking, and data handling—specifically byteorder, digest, dns_lookup, hex,... | //! A foundation for building applications on Bitcoin SV using Rust.
extern crate byteorder;
extern crate digest;
extern crate dns_lookup;
extern crate hex;
#[macro_use]
extern crate log;
extern crate linked_hash_map;
extern crate murmur3;
extern crate rand;
extern crate ring;
extern crate ripemd160;
extern crate rust... | nvidia/nemotron-3.5-lightning-30b-a3b |
3d3d9197aaf70fc6-0 | 3d3d9197aaf70fc6 | brentongunning/rust-sv | https://github.com/brentongunning/rust-sv | f2c9e939b3da4bca4d6a9753c954426682c5a43b | MIT | src/messages/node_addr_ex.rs | file | node_addr_ex.rs | src/messages/node_addr_ex.rs | 1 | 62 | 62 | I need a Rust struct called NodeAddrEx that represents a Bitcoin SV node network address extended with a last connected timestamp. It should contain a u32 last_connected_time and a NodeAddr field. Implement the Serializable trait for it with read and write methods that use little-endian byte order to serialize/deserial... | use crate::messages::node_addr::NodeAddr;
use crate::util::{Result, Serializable};
use byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt};
use std::io;
use std::io::{Read, Write};
/// Node network address extended with a last connected time
#[derive(Debug, Default, PartialEq, Eq, Hash, Clone)]
pub struct NodeAddrE... | nvidia/nemotron-3.5-lightning-30b-a3b |
b7a7aaf28804a8cb-0 | b7a7aaf28804a8cb | brentongunning/rust-sv | https://github.com/brentongunning/rust-sv | f2c9e939b3da4bca4d6a9753c954426682c5a43b | MIT | src/messages/tx_out.rs | file | tx_out.rs | src/messages/tx_out.rs | 1 | 59 | 59 | I need a Rust struct for a Bitcoin SV transaction output called TxOut with a satoshis field of type i64 and a lock_script field of type Script. I need a size() method that returns the byte length as 8 plus the varint-encoded length of the script payload plus the payload length itself. I also need to implement the Seria... | use crate::script::Script;
use crate::util::{var_int, Result, Serializable};
use byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt};
use std::io;
use std::io::{Read, Write};
/// Transaction output
#[derive(Debug, PartialEq, Eq, Hash, Clone)]
pub struct TxOut {
/// Number of satoshis to spend
pub satoshis: ... | nvidia/nemotron-3.5-lightning-30b-a3b |
827de0e13d2c23a9-0 | 827de0e13d2c23a9 | brentongunning/rust-sv | https://github.com/brentongunning/rust-sv | f2c9e939b3da4bca4d6a9753c954426682c5a43b | MIT | src/messages/block_locator.rs | file | block_locator.rs | src/messages/block_locator.rs | 1 | 92 | 92 | I need a Rust implementation of a `BlockLocator` struct for a Bitcoin SV library that represents a message for locating blocks in the blockchain. The struct should store a protocol version (`u32`), a vector of `Hash256` block hashes, and a stop hash (`Hash256`). It must implement a `validate` method that returns an err... | use crate::messages::message::Payload;
use crate::messages::version::MIN_SUPPORTED_PROTOCOL_VERSION;
use crate::util::{var_int, Error, Hash256, Result, Serializable};
use byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt};
use std::io;
use std::io::{Read, Write};
/// Return results until either there are 2000 for ... | nvidia/nemotron-3.5-lightning-30b-a3b |
b5a3ee23f316125e-0 | b5a3ee23f316125e | brentongunning/rust-sv | https://github.com/brentongunning/rust-sv | f2c9e939b3da4bca4d6a9753c954426682c5a43b | MIT | src/messages/out_point.rs | file | out_point.rs | src/messages/out_point.rs | 1 | 63 | 63 | I need a Rust module that defines a struct representing a reference to a transaction output in a Bitcoin SV transaction. The struct should contain a 256-bit transaction hash and a 32-bit output index. It must implement a `Serializable` trait with `read` and `write` methods using `byteorder` for little-endian serializat... | use crate::util::{Hash256, Result, Serializable};
use byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt};
use std::io;
use std::io::{Read, Write};
/// The coinbase transaction input will have this hash
pub const COINBASE_OUTPOINT_HASH: Hash256 = Hash256([0; 32]);
/// The coinbase transaction input will have this i... | nvidia/nemotron-3.5-lightning-30b-a3b |
2c7111a21e028515-0 | 2c7111a21e028515 | brentongunning/rust-sv | https://github.com/brentongunning/rust-sv | f2c9e939b3da4bca4d6a9753c954426682c5a43b | MIT | src/messages/tx_in.rs | file | tx_in.rs | src/messages/tx_in.rs | 1 | 73 | 73 | I need a Rust struct `TxIn` for a Bitcoin SV message library representing a transaction input with fields `prev_output: OutPoint`, `unlock_script: Script`, and `sequence: u32`. I need a `size()` method that computes the byte size from `OutPoint::SIZE`, a variable-length integer encoding for the script length, the scrip... | use crate::messages::OutPoint;
use crate::script::Script;
use crate::util::{var_int, Result, Serializable};
use byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt};
use std::io;
use std::io::{Read, Write};
/// Transaction input
#[derive(Debug, Default, PartialEq, Eq, Hash, Clone)]
pub struct TxIn {
/// The prev... | nvidia/nemotron-3.5-lightning-30b-a3b |
259592f046d967c9-0 | 259592f046d967c9 | brentongunning/rust-sv | https://github.com/brentongunning/rust-sv | f2c9e939b3da4bca4d6a9753c954426682c5a43b | MIT | src/network/network.rs | file | network.rs | src/network/network.rs | 1 | 176 | 176 | I'm developing a Rust library for Bitcoin SV and need a module that defines network configuration and genesis block generation. I need an enum `Network` with variants `Mainnet`, `Testnet`, and `STN`, and associated methods: `from_u8(u8) -> Result<Network>` that converts an integer to the network type and returns `Error... | use crate::messages::{Block, BlockHeader, OutPoint, Tx, TxIn, TxOut};
use crate::network::SeedIter;
use crate::script::Script;
use crate::util::{Error, Hash256, Result};
use hex;
/// Network type
#[derive(Debug, PartialEq, Eq, Hash, Clone, Copy)]
pub enum Network {
Mainnet = 0,
Testnet = 1,
STN = 2,
}
imp... | nvidia/nemotron-3.5-lightning-30b-a3b |
c937730416f369c3-0 | c937730416f369c3 | brentongunning/rust-sv | https://github.com/brentongunning/rust-sv | f2c9e939b3da4bca4d6a9753c954426682c5a43b | MIT | src/peer/atomic_reader.rs | file | atomic_reader.rs | src/peer/atomic_reader.rs | 1 | 123 | 123 | I need a Rust struct that provides all-or-nothing reads from a `std::io::Read` implementer. The struct should store a mutable reference to the reader and an internal buffer. Implementing the `Read` trait, its `read` method should first attempt to satisfy the request from the buffer. If the buffer contains fewer bytes t... | use std::io;
use std::io::Read;
/// Wraps a reader so reads become all-or-nothing
pub struct AtomicReader<'a> {
buf: Vec<u8>,
reader: &'a mut dyn Read,
}
impl<'a> AtomicReader<'a> {
pub fn new(reader: &mut dyn Read) -> AtomicReader {
let buf = Vec::new();
AtomicReader { buf, reader }
}... | nvidia/nemotron-3.5-lightning-30b-a3b |
11aa98bd4e55130d-0 | 11aa98bd4e55130d | brentongunning/rust-sv | https://github.com/brentongunning/rust-sv | f2c9e939b3da4bca4d6a9753c954426682c5a43b | MIT | src/peer/peer.rs | file | peer.rs | src/peer/peer.rs | 1 | 430 | 430 | I need a Rust Peer struct for a Bitcoin SV peer-to-peer connection that initiates a TCP connection to a remote node and performs the full protocol handshake: sending a Version message, reading the peer's Version and Verack, sending our Verack, and broadcasting a Ping with a timestamp nonce. The peer must be validated a... | use crate::messages::{Message, MessageHeader, Ping, Version, NODE_BITCOIN_CASH, NODE_NETWORK};
use crate::network::Network;
use crate::peer::atomic_reader::AtomicReader;
use crate::util::rx::{Observable, Observer, Single, Subject};
use crate::util::{secs_since, Error, Result};
use snowflake::ProcessUniqueId;
use std::f... | nvidia/nemotron-3.5-lightning-30b-a3b |
3bea23c097c0be7d-0 | 3bea23c097c0be7d | brentongunning/rust-sv | https://github.com/brentongunning/rust-sv | f2c9e939b3da4bca4d6a9753c954426682c5a43b | MIT | src/messages/inv_vect.rs | file | inv_vect.rs | src/messages/inv_vect.rs | 1 | 69 | 69 | I need a Rust module for a Bitcoin SV P2P message that represents an inventory vector. Define constant values for object types (such as error, transaction, block, filtered block, and compact block), and a struct named InvVect containing a u32 object type and a 32-byte hash using the project's Hash256 type. Include a co... | use crate::util::{Hash256, Result, Serializable};
use byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt};
use std::io;
use std::io::{Read, Write};
// Inventory vector types
/// May be ignored
pub const INV_VECT_ERROR: u32 = 0;
/// Hash of a transaction
pub const INV_VECT_TX: u32 = 1;
/// Hash of a block header.
p... | nvidia/nemotron-3.5-lightning-30b-a3b |
de302e645ee54316-0 | de302e645ee54316 | brentongunning/rust-sv | https://github.com/brentongunning/rust-sv | f2c9e939b3da4bca4d6a9753c954426682c5a43b | MIT | src/script/mod.rs | file | mod.rs | src/script/mod.rs | 1 | 307 | 307 | I'm building a Bitcoin SV scripting module in Rust and need a Script type that wraps Vec<u8> with methods new(), append(u8), append_slice(&[u8]), and append_data(&[u8]) that auto-encodes data using OP_0, OP_PUSH + len, OP_PUSHDATA1, OP_PUSHDATA2, or OP_PUSHDATA4 based on length. The module must include an eval(&self, c... | //! Script opcodes and interpreter
//!
//! # Examples
//!
//! Evaluate a script that divides two numbers:
//!
//! ```rust
//! use sv::script::op_codes::*;
//! use sv::script::{Script, TransactionlessChecker, NO_FLAGS};
//!
//! let mut script = Script::new();
//! script.append(OP_10);
//! script.append(OP_5);
//! script... | nvidia/nemotron-3.5-lightning-30b-a3b |
6d782ec82124f16b-0 | 6d782ec82124f16b | brentongunning/rust-sv | https://github.com/brentongunning/rust-sv | f2c9e939b3da4bca4d6a9753c954426682c5a43b | MIT | src/messages/mod.rs | file | mod.rs | src/messages/mod.rs | 1 | 116 | 116 | I need a Rust module that sets up the peer-to-peer network protocol message structure for a Bitcoin SV library. It should declare and re-export submodules for all message types—addresses, blocks, transaction inputs and outputs, headers, inventory, bloom filters, and versioning. The module must include documentation wit... | //! Peer-to-peer network protocol messages
//!
//! # Examples
//!
//! Decode a network message
//!
//! ```rust
//! use sv::messages::Message;
//! use sv::network::Network;
//! use std::io::Cursor;
//!
//! let bytes = [
//! 227, 225, 243, 232, 104, 101, 97, 100, 101, 114, 115,
//! 0, 0, 0, 0, 0, 1, 0, 0, 0, 20, ... | nvidia/nemotron-3.5-lightning-30b-a3b |
e4ff8294d3c36d18-0 | e4ff8294d3c36d18 | brentongunning/rust-sv | https://github.com/brentongunning/rust-sv | f2c9e939b3da4bca4d6a9753c954426682c5a43b | MIT | src/util/hash160.rs | file | hash160.rs | src/util/hash160.rs | 1 | 38 | 38 | I need a Rust function that computes a 160-bit hash from arbitrary data by first applying SHA-256 and then RIPEMD-160, returning the result as a fixed-size `Hash160` type. The function should accept a byte slice, use the `ring` crate for SHA-256 and the `ripemd160` crate for the second pass, and the `Hash160` struct sh... | use digest::{FixedOutput, Input};
use hex;
use ring::digest::{digest, SHA256};
use ripemd160::{Digest, Ripemd160};
use std::fmt;
/// 160-bit hash for public key addresses
#[derive(Default, Clone, Copy, PartialEq, Eq, Hash)]
pub struct Hash160(pub [u8; 20]);
/// Hashes a data array once with SHA256 and again with RIPE... | nvidia/nemotron-3.5-lightning-30b-a3b |
718bb128308b2413-0 | 718bb128308b2413 | brentongunning/rust-sv | https://github.com/brentongunning/rust-sv | f2c9e939b3da4bca4d6a9753c954426682c5a43b | MIT | src/transaction/mod.rs | file | mod.rs | src/transaction/mod.rs | 1 | 52 | 52 | I need a Rust function named generate_signature that takes a 32-byte private key reference, a reference to a Hash256 value representing a transaction sighash, and a u8 sighash type, and returns a Result<Vec<u8>> containing a DER-encoded secp256k1 signature with the sighash type byte appended. The function should use th... | //! Build and sign transactions
//!
//! # Examples
//!
//! Sign a transaction:
//!
//! ```rust
//! use sv::messages::{Tx, TxIn};
//! use sv::transaction::generate_signature;
//! use sv::transaction::p2pkh::{create_lock_script, create_unlock_script};
//! use sv::transaction::sighash::{sighash, SigHashCache, SIGHASH_FORK... | nvidia/nemotron-3.5-lightning-30b-a3b |
84163411ea4f3d20-0 | 84163411ea4f3d20 | brentongunning/rust-sv | https://github.com/brentongunning/rust-sv | f2c9e939b3da4bca4d6a9753c954426682c5a43b | MIT | src/network/seed_iter.rs | file | seed_iter.rs | src/network/seed_iter.rs | 1 | 63 | 63 | I need a Rust iterator for a Bitcoin SV node that semi-randomly cycles through a list of DNS seeds to discover peer addresses. The iterator should accept a vector of seed hostnames and a port number, resolve each seed using `dns_lookup::lookup_host` to obtain IP addresses, and yield `(IpAddr, u16)` tuples. It must hand... | use dns_lookup::lookup_host;
use rand::{thread_rng, Rng};
use std::net::IpAddr;
/// Iterates through DNS seeds semi-randomly
#[derive(Clone)]
pub struct SeedIter {
/// Port that is common to all IPs
pub port: u16,
seeds: Vec<String>,
nodes: Vec<IpAddr>,
seed_index: usize,
node_index: usize,
... | nvidia/nemotron-3.5-lightning-30b-a3b |
4c004cdcd92c9172-0 | 4c004cdcd92c9172 | brentongunning/rust-sv | https://github.com/brentongunning/rust-sv | f2c9e939b3da4bca4d6a9753c954426682c5a43b | MIT | src/util/serdes.rs | file | serdes.rs | src/util/serdes.rs | 1 | 40 | 40 | I need implementations of a `Serializable` trait for fixed-size byte arrays in Rust. Specifically, I'm looking for `impl Serializable<[u8; 16]> for [u8; 16]` and `impl Serializable<[u8; 32]> for [u8; 32]` where the `read` method reads exactly 16 or 32 bytes from a `&mut dyn Read` and returns a `Result<[u8; 16]>` or `Re... | use crate::util::Result;
use std::io;
use std::io::{Read, Write};
/// An object that may be serialized and deserialized
pub trait Serializable<T> {
/// Reads the object from serialized form
fn read(reader: &mut dyn Read) -> Result<T>
where
Self: Sized;
/// Writes the object to serialized form
... | nvidia/nemotron-3.5-lightning-30b-a3b |
09c12e791da640e0-0 | 09c12e791da640e0 | brentongunning/rust-sv | https://github.com/brentongunning/rust-sv | f2c9e939b3da4bca4d6a9753c954426682c5a43b | MIT | src/network/mod.rs | file | mod.rs | src/network/mod.rs | 1 | 19 | 19 | Write a Rust module file for a Bitcoin SV network library that configures mainnet and testnet settings. The file should include documentation for mainnet and testnet, declare submodules `network` and `seed_iter`, and publicly re-export a `Network` type from `network` and a `SeedIter` iterator from `seed_iter`. Include ... | //! Configuration for mainnet and testnet
//!
//! # Examples
//!
//! Iterate through seed nodes:
//!
//! ```no_run, rust
//! use sv::network::Network;
//!
//! for (ip, port) in Network::Mainnet.seed_iter() {
//! println!("Seed node {:?}:{}", ip, port);
//! }
//! ```
mod network;
mod seed_iter;
pub use self::netwo... | nvidia/nemotron-3.5-lightning-30b-a3b |
07e316d6607de883-0 | 07e316d6607de883 | brentongunning/rust-sv | https://github.com/brentongunning/rust-sv | f2c9e939b3da4bca4d6a9753c954426682c5a43b | MIT | src/wallet/mod.rs | file | mod.rs | src/wallet/mod.rs | 1 | 10 | 10 | I need a Rust module for wallet and key management in a Bitcoin SV library. The module should define two private submodules: one for extended key derivation and one for mnemonic phrase handling. The public interface must re-export from the extended key submodule a derivation function, an extended key type, a key type s... | //! Wallet and key management
mod extended_key;
mod mnemonic;
pub use self::extended_key::{
derive_extended_key, ExtendedKey, ExtendedKeyType, HARDENED_KEY, MAINNET_PRIVATE_EXTENDED_KEY,
MAINNET_PUBLIC_EXTENDED_KEY, TESTNET_PRIVATE_EXTENDED_KEY, TESTNET_PUBLIC_EXTENDED_KEY,
};
pub use self::mnemonic::{load_wo... | nvidia/nemotron-3.5-lightning-30b-a3b |
fbbae2a3f6326294-0 | fbbae2a3f6326294 | brentongunning/rust-sv | https://github.com/brentongunning/rust-sv | f2c9e939b3da4bca4d6a9753c954426682c5a43b | MIT | src/util/result.rs | file | result.rs | src/util/result.rs | 1 | 138 | 138 | I need a Rust source file that defines a custom error type and a Result alias for a cryptocurrency library. The error type should be an enum handling variants for bad arguments, bad data, base58 decoding errors, hex decoding errors, UTF8 parsing errors, illegal states, invalid operations, IO errors, integer parsing err... | use hex::FromHexError;
use ring;
use rust_base58::base58::FromBase58Error;
use secp256k1;
use std;
use std::io;
use std::string::FromUtf8Error;
/// Standard error type used in the library
#[derive(Debug)]
pub enum Error {
/// An argument provided is invalid
BadArgument(String),
/// The data given is not va... | nvidia/nemotron-3.5-lightning-30b-a3b |
bf3a2052d125cdd6-0 | bf3a2052d125cdd6 | brentongunning/rust-sv | https://github.com/brentongunning/rust-sv | f2c9e939b3da4bca4d6a9753c954426682c5a43b | MIT | src/util/mod.rs | file | mod.rs | src/util/mod.rs | 1 | 46 | 46 | I need a Rust module that provides miscellaneous helpers for working with Bitcoin SV, including a function `secs_since` that takes a `std::time::SystemTime` and returns a `u32` representing the number of seconds elapsed, panicking if the given time is in the future. Additionally, it should define and publicize constant... | //! Miscellaneous helpers
use std::time::SystemTime;
#[allow(dead_code)]
mod bits;
mod bloom_filter;
#[allow(dead_code)]
mod future;
#[allow(dead_code)]
mod hash160;
mod hash256;
#[allow(dead_code)]
mod latch;
mod result;
pub mod rx;
mod serdes;
pub(crate) mod var_int;
pub(crate) use self::bits::{lshift, rshift, Bit... | nvidia/nemotron-3.5-lightning-30b-a3b |
f7d092c2d7d0a86c-0 | f7d092c2d7d0a86c | brentongunning/rust-sv | https://github.com/brentongunning/rust-sv | f2c9e939b3da4bca4d6a9753c954426682c5a43b | MIT | src/peer/mod.rs | file | mod.rs | src/peer/mod.rs | 1 | 87 | 87 | I need a Rust module for a Bitcoin SV peer networking library that handles node connections and message exchange. The module should define a Peer type that can connect to a node given an IP address, port, network type, initial version message, and a peer filter. It must support sending messages like Version and Ping, a... | //! Node connection and message handling
//!
//! # Examples
//!
//! Send and receive a message to a node syncronously:
//!
//! ```no_run, rust
//! use sv::messages::{Message, Ping, Version, NODE_BITCOIN_CASH, PROTOCOL_VERSION};
//! use sv::network::Network;
//! use sv::peer::{Peer, SVPeerFilter};
//! use sv::util::rx::... | nvidia/nemotron-3.5-lightning-30b-a3b |
facadbbf5cb790ae-0 | facadbbf5cb790ae | lightningdevkit/rust-lightning | https://github.com/lightningdevkit/rust-lightning | 48e8d4745e5fd54398e24bcce2921c2b075f99c5 | Apache-2.0 OR MIT | fuzz/src/bech32_parse.rs | file | bech32_parse.rs | fuzz/src/bech32_parse.rs | 1 | 57 | 57 | I need a Rust fuzz helper that defines a `Bytes` type wrapping `Vec<u8>`, implements `Bech32Encode` with HRP `"lno"` from `lightning::offers::parse`, provides a `TryFrom<Vec<u8>>` conversion returning `Bolt12ParseError`, implements `Display` and `AsRef<[u8]>`, and includes a test function that round-trips Bech32 string... | // This file is Copyright its original authors, visible in version control
// history.
//
// This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
// or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
// You may... | nvidia/nemotron-3.5-lightning-30b-a3b |
b7f6ce453143e56f-0 | b7f6ce453143e56f | lightningdevkit/rust-lightning | https://github.com/lightningdevkit/rust-lightning | 48e8d4745e5fd54398e24bcce2921c2b075f99c5 | Apache-2.0 OR MIT | fuzz/src/gossip_discovery.rs | file | gossip_discovery.rs | fuzz/src/gossip_discovery.rs | 1 | 265 | 265 | I need a Rust fuzz test module that stress-tests a lightning P2PGossipSync and NetworkGraph by iterating over raw byte input to simulate gossip message flows. The code should dispatch on the first byte modulo 7 to handle node announcements, channel announcements (with optional UTXO registration via make_funding_redeems... | // This file is Copyright its original authors, visible in version control
// history.
//
// This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
// or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
// You may... | nvidia/nemotron-3.5-lightning-30b-a3b |
7f7738785e6b89cd-0 | 7f7738785e6b89cd | lightningdevkit/rust-lightning | https://github.com/lightningdevkit/rust-lightning | 48e8d4745e5fd54398e24bcce2921c2b075f99c5 | Apache-2.0 OR MIT | fuzz/src/feature_flags.rs | file | feature_flags.rs | fuzz/src/feature_flags.rs | 1 | 97 | 97 | I need a Rust module to fuzz-test the `FeatureFlags` type from the Lightning Network library. The module should process raw byte data interpreted as a sequence of 3-byte commands (command byte, index, value), and mutate both a `Vec<u8>` and a `FeatureFlags` instance accordingly. It must support three commands: command ... | // This file is Copyright its original authors, visible in version control
// history.
//
// This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
// or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
// You may... | nvidia/nemotron-3.5-lightning-30b-a3b |
72916606d0f8ff9f-0 | 72916606d0f8ff9f | lightningdevkit/rust-lightning | https://github.com/lightningdevkit/rust-lightning | 48e8d4745e5fd54398e24bcce2921c2b075f99c5 | Apache-2.0 OR MIT | fuzz/src/bolt11_deser.rs | file | bolt11_deser.rs | fuzz/src/bolt11_deser.rs | 1 | 76 | 76 | I need a Rust fuzz test module for BOLT11 invoice deserialization from raw byte data. The code should parse a bech32 HRP prefix from the beginning of the input, decode the remaining bytes as base32, reconstruct the data part and assert that re-encoding is lossless, check for a PayeePubKey tagged field and skip signatur... | // This file is Copyright its original authors, visible in version control
// history.
//
// This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
// or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
// You may... | nvidia/nemotron-3.5-lightning-30b-a3b |
8b2476a3ccacf940-0 | 8b2476a3ccacf940 | lightningdevkit/rust-lightning | https://github.com/lightningdevkit/rust-lightning | 48e8d4745e5fd54398e24bcce2921c2b075f99c5 | Apache-2.0 OR MIT | bench/benches/bench.rs | file | bench.rs | bench/benches/bench.rs | 1 | 26 | 26 | Write a Criterion benchmark module that groups routing, channel management, persistence, gossip, and scoring benchmarks for a Rust Lightning implementation, including route generation with zero penalty and probabilistic scorers, MPP variants, large MPP scenarios, secure random bytes, channel sends, filesystem persister... | extern crate lightning;
extern crate lightning_persister;
extern crate criterion;
use criterion::{criterion_group, criterion_main};
criterion_group!(benches,
// Note that benches run in the order given here. Thus, they're sorted according to how likely
// developers are to be working on the specific code listed, t... | nvidia/nemotron-3.5-lightning-30b-a3b |
e4c7ddde13b7c5e3-0 | e4c7ddde13b7c5e3 | lightningdevkit/rust-lightning | https://github.com/lightningdevkit/rust-lightning | 48e8d4745e5fd54398e24bcce2921c2b075f99c5 | Apache-2.0 OR MIT | fuzz/src/indexedmap.rs | file | indexedmap.rs | fuzz/src/indexedmap.rs | 1 | 183 | 183 | I need a Rust source file for fuzz-testing lightning::util::indexed_map::IndexedMap against std::collections::BTreeMap. The module should accept a byte slice and a logger output, parse consecutive byte pairs as u8 key-value pairs, and insert them into both an IndexedMap and a BTreeMap while asserting equivalence after ... | // This file is Copyright its original authors, visible in version control
// history.
//
// This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
// or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
// You may... | nvidia/nemotron-3.5-lightning-30b-a3b |
f0847b16d2f2c994-0 | f0847b16d2f2c994 | lightningdevkit/rust-lightning | https://github.com/lightningdevkit/rust-lightning | 48e8d4745e5fd54398e24bcce2921c2b075f99c5 | Apache-2.0 OR MIT | fuzz/src/invoice_deser.rs | file | invoice_deser.rs | fuzz/src/invoice_deser.rs | 1 | 31 | 31 | I need a Rust module that implements a function to round-trip a Bolt12 invoice: parse a byte slice into a `Bolt12Invoice` using `TryFrom`, serialize it back using `Writeable::write`, and assert the original bytes are recovered. Additionally, I need a C FFI function `invoice_deser_run` that executes this test with a `te... | // This file is Copyright its original authors, visible in version control
// history.
//
// This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
// or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
// You may... | nvidia/nemotron-3.5-lightning-30b-a3b |
0e1294e3c1f75f8b-0 | 0e1294e3c1f75f8b | lightningdevkit/rust-lightning | https://github.com/lightningdevkit/rust-lightning | 48e8d4745e5fd54398e24bcce2921c2b075f99c5 | Apache-2.0 OR MIT | fuzz/src/base32.rs | file | base32.rs | fuzz/src/base32.rs | 1 | 58 | 58 | I need a Rust module that implements a base32 fuzz test using the `lightning::util::base32` crate. The module should define a function that takes a byte slice, decodes it using `base32::Alphabet::RFC4648 { padding: true }` and `padding: false`, encodes the decoded result back, verifies the encoded string matches the up... | // This file is Copyright its original authors, visible in version control
// history.
//
// This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
// or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
// You may... | nvidia/nemotron-3.5-lightning-30b-a3b |
fd068d2b73e79f7e-0 | fd068d2b73e79f7e | lightningdevkit/rust-lightning | https://github.com/lightningdevkit/rust-lightning | 48e8d4745e5fd54398e24bcce2921c2b075f99c5 | Apache-2.0 OR MIT | fuzz/src/lsps_message.rs | file | lsps_message.rs | fuzz/src/lsps_message.rs | 1 | 114 | 114 | I need a Rust module for fuzzing LSPs message handling that bootstraps a test Lightning node and processes a raw byte slice as an LSPs message. The module must expose a function do_test(data: &[u8]) that: sets the network to Bitcoin, creates test utilities (TestBroadcaster, TestChainSource, TestLogger, TestStore, TestF... | use crate::utils::test_logger;
use bitcoin::blockdata::constants::genesis_block;
use bitcoin::hashes::{sha256, Hash};
use bitcoin::secp256k1::{PublicKey, Secp256k1, SecretKey};
use bitcoin::Network;
use lightning::chain::{chainmonitor, BlockLocator};
use lightning::ln::channelmanager::{ChainParameters, ChannelManager... | nvidia/nemotron-3.5-lightning-30b-a3b |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.